Fluent in C++
-
So, as some of the longer term viewers may know, I used to be a C++ developer; way back in the mists of time. I loved C++ and then the new girl came to town and seduced me with her wiles. No longer would I put up with manual memory management, iterating over for statements when I could use the seductive foreach. Well, I have recently started getting quite heavily back into C++ using the newer additions to the language such as auto and for (auto index : my_vector) as a foreach. The features that are available now are great and C++ really has matured. So much so that I'm using it to write some drone software. I'm a big fan of fluent interfaces so I thought I'd play around and see how they work in C++ to see if I still want to keep with the new C++ and damn it, it's so straightforward.
#pragma once
#include <librealsense/rs.hpp>class RealSenseStream
{
public:
explicit RealSenseStream(rs::device* device)
{
this->device = device;
}
~RealSenseStream()
{
}RealSenseStream &WithDepth(rs::preset preset)
{
device->enable_stream(rs::stream::depth, preset);
return *this;
}RealSenseStream &WithColor(rs::preset preset)
{
device->enable_stream(rs::stream::color, preset);
return *this;
}private:
rs::device* device;
};This space for rent
Indeed, modern C++ ist an elegant language. It has one huge flaw though: It's legacy. I, for example, can write elegant code in modern C++, but several of my coworkers can't. Some even brush me off with "I've learned it like that in the 60s and I won't learn anything new". Some even treat the C++-compiler as a C-compiler and write plain C, bluntly ignoring all the wonders of std::string or array. This makes me think that C++ still isn't ready for prime-time. The standard needs to deprecate all this legacy stuff and throw warnings all over the place if someone refuses to dig into the last 50 years of CS progression. If C++ starts doing that, I'll take it seriously. Until then, I'll stick to C# (unless I'm on a ressource-contrained embedded target).
-
So, as some of the longer term viewers may know, I used to be a C++ developer; way back in the mists of time. I loved C++ and then the new girl came to town and seduced me with her wiles. No longer would I put up with manual memory management, iterating over for statements when I could use the seductive foreach. Well, I have recently started getting quite heavily back into C++ using the newer additions to the language such as auto and for (auto index : my_vector) as a foreach. The features that are available now are great and C++ really has matured. So much so that I'm using it to write some drone software. I'm a big fan of fluent interfaces so I thought I'd play around and see how they work in C++ to see if I still want to keep with the new C++ and damn it, it's so straightforward.
#pragma once
#include <librealsense/rs.hpp>class RealSenseStream
{
public:
explicit RealSenseStream(rs::device* device)
{
this->device = device;
}
~RealSenseStream()
{
}RealSenseStream &WithDepth(rs::preset preset)
{
device->enable_stream(rs::stream::depth, preset);
return *this;
}RealSenseStream &WithColor(rs::preset preset)
{
device->enable_stream(rs::stream::color, preset);
return *this;
}private:
rs::device* device;
};This space for rent
Welcome back to the codeface! ;) C++ 14 is amazing, and a very different language from the one I had to use until a few years ago. We had the pleasure of meeting Bjarne at the ACCU Conference a few years back when C++ 11 first landed, and his enthusiasm for the future of the language was infectious. I'm a big fan of std::shared_ptr, auto, range based loops and std::thread. All have (and still are) simplifying our code significantly. Then of course there are move semantics and rvalue references, which can dramatically improve performance. But more is coming - C++ 17[^] is nearly done (though sadly without the modules proposal[^], despite it already being implemented in Clang) and C++ 20 is being planned.
Anna (@annajayne) Tech Blog | Visual Lint "Why would anyone prefer to wield a weapon that takes both hands at once, when they could use a lighter (and obviously superior) weapon that allows you to wield multiple ones at a time, and thus supports multi-paradigm carnage?"
-
Welcome back to the codeface! ;) C++ 14 is amazing, and a very different language from the one I had to use until a few years ago. We had the pleasure of meeting Bjarne at the ACCU Conference a few years back when C++ 11 first landed, and his enthusiasm for the future of the language was infectious. I'm a big fan of std::shared_ptr, auto, range based loops and std::thread. All have (and still are) simplifying our code significantly. Then of course there are move semantics and rvalue references, which can dramatically improve performance. But more is coming - C++ 17[^] is nearly done (though sadly without the modules proposal[^], despite it already being implemented in Clang) and C++ 20 is being planned.
Anna (@annajayne) Tech Blog | Visual Lint "Why would anyone prefer to wield a weapon that takes both hands at once, when they could use a lighter (and obviously superior) weapon that allows you to wield multiple ones at a time, and thus supports multi-paradigm carnage?"
It's a vastly different language to the one I knew. As I have the advantage of writing from scratch, I have the advantage of not having to deal with legacy and cruft. It's a liberating experience.
This space for rent
-
Indeed, modern C++ ist an elegant language. It has one huge flaw though: It's legacy. I, for example, can write elegant code in modern C++, but several of my coworkers can't. Some even brush me off with "I've learned it like that in the 60s and I won't learn anything new". Some even treat the C++-compiler as a C-compiler and write plain C, bluntly ignoring all the wonders of std::string or array. This makes me think that C++ still isn't ready for prime-time. The standard needs to deprecate all this legacy stuff and throw warnings all over the place if someone refuses to dig into the last 50 years of CS progression. If C++ starts doing that, I'll take it seriously. Until then, I'll stick to C# (unless I'm on a ressource-contrained embedded target).
This sounds like me. I was once quite proficient in C++ but then I got into C# and simply haven't updated my C++ at all. Last time I used it was in 2003 I think. The latest versions look so different and have so many new features that I would really have to study hard to catch up.
We're philosophical about power outages here. A.C. come, A.C. go.
-
So, as some of the longer term viewers may know, I used to be a C++ developer; way back in the mists of time. I loved C++ and then the new girl came to town and seduced me with her wiles. No longer would I put up with manual memory management, iterating over for statements when I could use the seductive foreach. Well, I have recently started getting quite heavily back into C++ using the newer additions to the language such as auto and for (auto index : my_vector) as a foreach. The features that are available now are great and C++ really has matured. So much so that I'm using it to write some drone software. I'm a big fan of fluent interfaces so I thought I'd play around and see how they work in C++ to see if I still want to keep with the new C++ and damn it, it's so straightforward.
#pragma once
#include <librealsense/rs.hpp>class RealSenseStream
{
public:
explicit RealSenseStream(rs::device* device)
{
this->device = device;
}
~RealSenseStream()
{
}RealSenseStream &WithDepth(rs::preset preset)
{
device->enable_stream(rs::stream::depth, preset);
return *this;
}RealSenseStream &WithColor(rs::preset preset)
{
device->enable_stream(rs::stream::color, preset);
return *this;
}private:
rs::device* device;
};This space for rent
All of the input and output operators in old, old C++ offered fluent interfaces. cin >> x >> y; cout << setw(10) << x << setw(12) << y << endl; Ignoring references, you can always just
return this;
at the end of a function which requires code like:
variable->f1(args1)->f2(args2)->f3(args3);
-
All of the input and output operators in old, old C++ offered fluent interfaces. cin >> x >> y; cout << setw(10) << x << setw(12) << y << endl; Ignoring references, you can always just
return this;
at the end of a function which requires code like:
variable->f1(args1)->f2(args2)->f3(args3);
I'm happy enough with what I've got now.
This space for rent
-
It's a vastly different language to the one I knew. As I have the advantage of writing from scratch, I have the advantage of not having to deal with legacy and cruft. It's a liberating experience.
This space for rent
It certainly is. :) Thought of coming along to the ACCU Conference? There's a strong C++ track (and sometimes even a C++ Pub Quiz with free beer...) there.
Anna (@annajayne) Tech Blog | Visual Lint "Why would anyone prefer to wield a weapon that takes both hands at once, when they could use a lighter (and obviously superior) weapon that allows you to wield multiple ones at a time, and thus supports multi-paradigm carnage?"
-
It certainly is. :) Thought of coming along to the ACCU Conference? There's a strong C++ track (and sometimes even a C++ Pub Quiz with free beer...) there.
Anna (@annajayne) Tech Blog | Visual Lint "Why would anyone prefer to wield a weapon that takes both hands at once, when they could use a lighter (and obviously superior) weapon that allows you to wield multiple ones at a time, and thus supports multi-paradigm carnage?"
It depends how serious I get with this drone software. The more I'm playing around with this, the more I love working with drones and I can see me going further with it.
This space for rent
-
It depends how serious I get with this drone software. The more I'm playing around with this, the more I love working with drones and I can see me going further with it.
This space for rent
Sounds cool. Have fun!
Anna (@annajayne) Tech Blog | Visual Lint "Why would anyone prefer to wield a weapon that takes both hands at once, when they could use a lighter (and obviously superior) weapon that allows you to wield multiple ones at a time, and thus supports multi-paradigm carnage?"
-
Sounds cool. Have fun!
Anna (@annajayne) Tech Blog | Visual Lint "Why would anyone prefer to wield a weapon that takes both hands at once, when they could use a lighter (and obviously superior) weapon that allows you to wield multiple ones at a time, and thus supports multi-paradigm carnage?"
I'll be writing this up and posting video footage so you will be able to take a look at least at some of the code. It's really cool stuff.
This space for rent
-
I'll be writing this up and posting video footage so you will be able to take a look at least at some of the code. It's really cool stuff.
This space for rent
Look forward to it :)
Anna (@annajayne) Tech Blog | Visual Lint "Why would anyone prefer to wield a weapon that takes both hands at once, when they could use a lighter (and obviously superior) weapon that allows you to wield multiple ones at a time, and thus supports multi-paradigm carnage?"
-
So, as some of the longer term viewers may know, I used to be a C++ developer; way back in the mists of time. I loved C++ and then the new girl came to town and seduced me with her wiles. No longer would I put up with manual memory management, iterating over for statements when I could use the seductive foreach. Well, I have recently started getting quite heavily back into C++ using the newer additions to the language such as auto and for (auto index : my_vector) as a foreach. The features that are available now are great and C++ really has matured. So much so that I'm using it to write some drone software. I'm a big fan of fluent interfaces so I thought I'd play around and see how they work in C++ to see if I still want to keep with the new C++ and damn it, it's so straightforward.
#pragma once
#include <librealsense/rs.hpp>class RealSenseStream
{
public:
explicit RealSenseStream(rs::device* device)
{
this->device = device;
}
~RealSenseStream()
{
}RealSenseStream &WithDepth(rs::preset preset)
{
device->enable_stream(rs::stream::depth, preset);
return *this;
}RealSenseStream &WithColor(rs::preset preset)
{
device->enable_stream(rs::stream::color, preset);
return *this;
}private:
rs::device* device;
};This space for rent
-
So, as some of the longer term viewers may know, I used to be a C++ developer; way back in the mists of time. I loved C++ and then the new girl came to town and seduced me with her wiles. No longer would I put up with manual memory management, iterating over for statements when I could use the seductive foreach. Well, I have recently started getting quite heavily back into C++ using the newer additions to the language such as auto and for (auto index : my_vector) as a foreach. The features that are available now are great and C++ really has matured. So much so that I'm using it to write some drone software. I'm a big fan of fluent interfaces so I thought I'd play around and see how they work in C++ to see if I still want to keep with the new C++ and damn it, it's so straightforward.
#pragma once
#include <librealsense/rs.hpp>class RealSenseStream
{
public:
explicit RealSenseStream(rs::device* device)
{
this->device = device;
}
~RealSenseStream()
{
}RealSenseStream &WithDepth(rs::preset preset)
{
device->enable_stream(rs::stream::depth, preset);
return *this;
}RealSenseStream &WithColor(rs::preset preset)
{
device->enable_stream(rs::stream::color, preset);
return *this;
}private:
rs::device* device;
};This space for rent
You seem to be retaining the C# coding style, single-file and all :)
-
You seem to be retaining the C# coding style, single-file and all :)
I'm really not. It was just easier to post a sample like that. My real code is spread out.
This space for rent
-
C++ and MFC; I did everything I could to avoid that sack of shite: Basic Assembler PC COBOL Pascal C Access dBase Paradox VB Clipper FoxPro Visual FoxPro Delphi C# Windows Forms WPF ...
I spent a lot of time in MFC. Then I discovered ATL and wasee hooked until I moved to .NET.
This space for rent