Short examples of all modern C++ features

Posted on:November 19 2021

...or the monster that C++ has become.



C++ reinvented itself during the last years, and is barely recognizable now from the good old C++98. It's not like C++ was a simple language back then - quite the contrary. But on top of all this, so many new features have been added that it has become a monster.

And generally speaking, this is a good thing: You now have smart pointers, lambdas, ranges, a chrono library, threads, concepts, modules and so much more. But it can become quite overwhelming with all that new language features additionally. So I created a short overview with a quick (mostly) self explanatory examples, of some of features you might have missed:

Feature Example
Auto
auto a = 4 + 6; 
Lambdas
auto aLambda = [](auto a, auto b) 
  { return a < b; };
bool b = aLambda(5, 1.23);
Strongly typed enums
enum class 
{
  value1,
  value2
};
Static assert
static_assert( sizeof(x) == 4 );
Range based for
for (auto x : arr) 
{
  foo(x);
}
Type alias
using IntVector = std::vector;
Unicode strings
const char* utf8 = u8"foo";
const char16_t* utf16 = u"bar";
const char32_t* utf32 = U"baz";
Move and move contructors
struct X
{
  std::string str;
  
  X(): str("foo") { }
  X(const X& b) : str(b.str) { }
  X(X&& b) noexcept : str(std::move(b.str)) { }
};
override
struct A
{
  virtual void foo() {};
};
 
struct B : public A
{
  void foo() override {};
};
Designated initializers
struct A { int x; int y; int z; };
A a { .x = 1, .z = 2 };
Modules
import someModule;
  // now use features from that module
Range based for with init
int arr[255];			
for (int c = 0; auto& x : arr) 
{
  foo(x, c); ++c;
}
Auto returns
auto func(int n)
{
    return n + 1;
}
Consteval
static consteval int sqr(int n)
{
	return n * n;
}
Constinit
constinit auto sqrOf5 = sqr(5);
Concepts
template
concept IsComparable = requires(T a, T b) {
	{ a == b } -> std::same_as;
	{ a != b } -> std::same_as;
};

class myclass {
  void func(const IsComparable auto& a) { };
};
If with initializer
if (auto p = foobar(); p->value > 1) 
{
   printf("no");
}
Switch with initializer
switch (auto p = foobar(); auto x = p->value) 
{
 case 0: printf("yes"); break;
 case 1: printf("no"); break;
}
Constexpr if
 if constexpr (sizeof(int) == 1)
   return 0; 
Auto template parameters
template  class someclass
{
  static auto TConstant = value;
};
Space ship operator
auto operator<=>(const a&) const = default; 
Nested namespace definitions
namespace A::B::C 
{
  class myclass {	};
}
Inline variables
class ClassWithInlineVariable
{
    static inline int field = 42;
};
Trailing return type
auto foo(int p) -> int	{ return p * 42; }
Decltype
int n = 33;
decltype(n) t = n+4;
Structured binding
int arr[3] = {3,4,5};
auto [x,y,z] = arr;
Namespaces with attributes
namespace [[someAttribute]] myNamespace
{		
};
Enumerators with attributes
enum class myEnum
{		
  value1 [[anAttribute]],
  value2 [[anotherAttribute]] = 3
};





Comments:


The structured binding example leaves something to be desired...
xaos
Quote
2021-11-25 13:03:02


True, updated it, thx!
niko
Quote
2021-11-30 05:18:29


Add comment:


Posted by:


Enter the missing letter in: "Internati?nal"


Text:

 

  

Possible Codes


Feature Code
Link [url] www.example.com [/url]
Bold [b]bold text[/b]
Quote [quote]quoted text[/quote]
Code [code]source code[/code]

Emoticons