Tag Archives: C++14

Codexpert – 2015 Articles Summary

Microsoft Libraries and C++ Programming Language

Using Lambdas in MFC Applications – Part 1: Sorting Arrays
Presents how to sort MFC arrays using lambda expressions (C++11 and next).
Using Lambdas in MFC Applications – Part 2: Replacing Callback Functions
Shows examples of using lambda expressions (including nested lambdas) in MFC applications for replacing callback functions.
Using Lambdas in MFC Applications – Part 3: Dealing with C++ REST SDK
Demonstrates how to set up a Visual C++ project for using C++ REST SDK (Casablanca) in Visual Studio 2013. Also provides sample code and a MFC demo project.
Binary Literals and Digit Separators
This article provides an introduction to the new C++14 features binary literals and digit separators.
Easy Browse for Folder with MFC
Presents how to easily show a browse for folder dialog in MFC, using CShellManager::BrowseForFolder.
Easy Shadow Drawing with MFC
Shows how to easily draw shadows using CDrawingManager MFC class.
MFC Support for DirectWrite – Part 1: The Basics
Demonstrates basic text formatting and drawing by using Direct2D and DirectWrite wrapper classes in MFC.
MFC Support for DirectWrite – Part 2: Text Block Formatting
DirectWrite block text formatting in MFC applications.
MFC Support for DirectWrite – Part 3: Text Range Format
Shows how to format ranges of text in MFC using CD2DTextLayout and IDWriteTextLayout.
MFC Support for DirectWrite – Part 4: Inline Images
Shows how to override and implement IDWriteInlineObject methods to insert inline images in a DirectWrite text layout.
MFC Support for DirectWrite – Part 5: Typography
Performs fancy stylistic text rendering with DirectWrite in MFC.
MFC Support for DirectWrite – Part 6: Effects
A simple example of changing text range color in an MFC application with Direct2D/DirectWrite support.

What’s next?

We planned to continue the Direct2D/DirectWrite series but also other articles about programming with C++ using Microsoft Windows libraries like MFC, ATL, Windows API and so on.

Binary literals and digit separators

6 Replies

The C++14 standard provides two new small features to the language: binary literals and digit separators. They are already available in Clang 3.4 and GCC 4.9 and now Visual Studio 2015 RC has implemented them. They may not be something you can’t live without, but sometimes it’s convenient to have them. Let’s have a look.

In C++ it was possible to input integer literals in several bases: decimal, hexadecimal and octal. However, the binary base has been omitted (though other languages supported that). With C++14 binary is also supported and binary literals are introduced with the prefix 0b or 0B.

int i1 = 42;
int i2 = 052;
int i3 = 0x2A;
int i4 = 0b101010;

int i1 = 42;

int i2 = 052;

int i3 = 0x2A;

int i4 = 0b101010;

Binary literals can be used anywhere integral literals are expected.

enum class flags
{
   read     = 0b0001,
   write    = 0b0010,
   execute  = 0b0100
};

enum class flags

{

read = 0b0001,

write = 0b0010,

execute = 0b0100

};

What if you had to write large literals such as 0b101111000110000101001110, which is the binary representation of decimal 12345678? Sometimes it is convenient to separate groups of digits for more human readability.

C++14 defines the single quotation mark (') as a digit separator in integral and floating point literals. So the binary literal 0b101111000110000101001110 can be expressed in several ways:

int n1 = 0b1011'1100'0110'0001'0100'1110;
int n2 = 0b10111100'01100001'01001110;

1 2	int n1 = 0b1011'1100'0110'0001'0100'1110; int n2 = 0b10111100'01100001'01001110;

or maybe in hexadecimal:

int n3 = 0xbc'61'4e;

1	int n3 = 0xbc'61'4e;

The position of the single quotation marks in the integral or floating point literals is irrelevant, they are simply ignored when determining the value of the literal. All the following are equivalent (but probably only the first and the last make sense).

int n1 = 12345;
int n2 = 1'2'3'4'5;
int n3 = 1'23'4'5;
int n4 = 1'234'5;
int n5 = 12'3'45;
int n6 = 12'345;

int n1 = 12345;

int n2 = 1'2'3'4'5;

int n3 = 1'23'4'5;

int n4 = 1'234'5;

int n5 = 12'3'45;

int n6 = 12'345;

Using Lambdas in MFC Applications – Part 1: Sorting Arrays

1 Reply

Beginning with Visual Studio 2010 which supports lambda expressions introduced by C++11 standard, you can handily sort an MFC array like in the following example:

Sorting CStringArray by using a lambda expression

// Example #1
    // ...
    CStringArray arr;
    arr.Add(_T("John"));
    arr.Add(_T("Zorro"));
    arr.Add(_T("Sandy"));
    arr.Add(_T("Jimmy"));
    // ...

    bool bAscending = true;
    // ...

    std::sort(
        arr.GetData(),                                           // position of first element
        arr.GetData() + arr.GetSize(),                           // position one past the final element 
        [bAscending]                                             // lambda introducer
        (const CString& left, const CString& right)              // lambda formal parameters list
        { return bAscending ? (left < right) : (left > right); } // lambda body
        );
    // ...

// Example #1

// ...

CStringArray arr;

arr.Add(_T("John"));

arr.Add(_T("Zorro"));

arr.Add(_T("Sandy"));

arr.Add(_T("Jimmy"));

// ...

bool bAscending = true;

// ...

std::sort(

arr.GetData(), // position of first element

arr.GetData() + arr.GetSize(), // position one past the final element

[bAscending] // lambda introducer

(const CString& left, const CString& right) // lambda formal parameters list

{ return bAscending ? (left < right) : (left > right); } // lambda body

);

// ...

Of course, you can write similar code for other types of MFC arrays like CArray, CUIntArray, and so on.
But also you can easily write a kind of “generic lambda” in order to sort any type of MFC arrays.

Using decltype to sort any type of MFC array

// Example #2
    // ...
    std::sort(
        arr.GetData(), 
        arr.GetData() + arr.GetSize(),
        [bAscending]
        (decltype(*arr.GetData()) left, decltype(*arr.GetData()) right)
        { return bAscending ? (left < right) : (left > right); }
        );
    // ...

// Example #2

// ...

std::sort(

arr.GetData(),

arr.GetData() + arr.GetSize(),

[bAscending]

(decltype(*arr.GetData()) left, decltype(*arr.GetData()) right)

{ return bAscending ? (left < right) : (left > right); }

);

// ...

That’s pretty cool… However would be nice to be possible to get rid of “wordy” constructions like “decltype(*arr.GetData())” in the lambda’s formal parameters list. Good news! There is a proposal for next C++ standards: using auto type-specifier in order to make generic lambda expressions (which accept any type of arguments). And that is already supported in Visual Studio 2015.

Using generic (polymorphic) lambda expressions

    // Example #3
    std::sort(
        arr.GetData(),
        arr.GetData() + arr.GetSize(),
        [bAscending]                                         
        (auto left, auto right)                                
        { return bAscending ? (left < right) : (left > right); }
        );

// Example #3

std::sort(

arr.GetData(),

arr.GetData() + arr.GetSize(),

[bAscending]

(auto left, auto right)

{ return bAscending ? (left < right) : (left > right); }

);

Notes

Some people may claim that using MFC collection classes is obsolete and must use STL containers instead. That’s an old subject of arguing but it’s not in scope of this short article.
It simply presents how to sort MFC arrays by using lambda expressions.

References and related articles

MSDN: Lambda Expressions in C++
cppreference.com: std::sort
codexpert blog: Let’s Write a “Hello Lambda!”
codexpert blog: Using Lambdas in MFC Applications – Part 2: Replacing Callback Functions
isocpp.org: Generic (Polymorphic) Lambda Expressions (Revision 3)
Visual C++ Team Blog: Visual Studio 2015 Preview is Now Available

User defined literals

3 Replies

The C++ language defines various built-in literals (numerical, character, string, boolean and pointer) and a series of prefixes and suffixes to specify some of them. The suffix or prefix is part of the literal.

auto b = true;     // boolean
auto s = "sample"; // const char[7]
auto i = 128;      // int
auto d = 128.0;    // double
auto p = nullptr;  // nullptr_t

// with prefixes
auto w = L"text";  // const wchar_t[5]
auto h = 0xBAD;    // int (in hexadecimal representation)

// with suffixes
auto a = 128u;     // unsigned int
auto l = 128l;     // signed long
auto f = 128.0f;   // float

auto b = true; // boolean

auto s = "sample"; // const char[7]

auto i = 128; // int

auto d = 128.0; // double

auto p = nullptr; // nullptr_t

// with prefixes

auto w = L"text"; // const wchar_t[5]

auto h = 0xBAD; // int (in hexadecimal representation)

// with suffixes

auto a = 128u; // unsigned int

auto l = 128l; // signed long

auto f = 128.0f; // float

The C++11 standard introduced the possibility to create user-defined literals, that are basically built-in type literals (integer, float, char or string) followed by a used-defined suffix. User-defined literals enable the creation of new objects based on the built-in literal value and the applied user-defined suffix.

auto temp = 77_fah;       // 77 Fahrenheit degrees = 25 Celsius degrees
auto size = 1_KB;         // 1 kilobyte = 1024 bytes
auto emp  = "marius"_dev; // a user defined type Developer

auto temp = 77_fah; // 77 Fahrenheit degrees = 25 Celsius degrees

auto size = 1_KB; // 1 kilobyte = 1024 bytes

auto emp = "marius"_dev; // a user defined type Developer

A bit of theory

A user-defined literal is treated as a call to a literal operator or a literal operator template. User-defined literals have two forms:

raw: a sequence of characters; the literal 0xBAD is in raw form is ‘0’, ‘x’, ‘B’, ‘A’, ‘D’
cooked: is the compiler interpreted type of the sequence of characters; the literal 0xBAD is the integer 2898 in cooked form.

User-defined literals:

support only the suffix form; defining prefixes is not possible;
begin with a underscore (‘_’); all suffixes that begin with any other character except underscore are reserved by the standard;
can be extended in both raw and cooked form; the exception is represented by strings that can only be extended in the cooked form

Cooked literals

The literal operator called for a cooked literal has following form:

OutputType operator "" _suffix(InputType);

1	OutputType operator "" _suffix(InputType);

Only several input types are allowed:

for integral literals (decimal, octal, hexadecimal or binary) the type is unsigned long long (the reason for unsigned is that the sign is not part of a numeric literal, but is in fact a unary operator applied to the numerical value).

C++

OutputType operator "" _suffix(unsigned long long);

1

OutputType operator "" _suffix(unsigned long long);
for floating point types the type is long double:

C++

OutputType operator "" _suffix(long double);

1

OutputType operator "" _suffix(long double);

for characters the type is char, wchar_t, char16_t or char32_t:

OutputType operator "" _suffix(char);
OutputType operator "" _suffix(wchar_t);
OutputType operator "" _suffix(char16_t);
OutputType operator "" _suffix(char32_t);

OutputType operator "" _suffix(char);

OutputType operator "" _suffix(wchar_t);

OutputType operator "" _suffix(char16_t);

OutputType operator "" _suffix(char32_t);

for strings the type is char const *, wchar_t const *, char16_t const * or char32_t const *:

OutputType operator "" _suffix(char const *, std::size_t);
OutputType operator "" _suffix(wchar_t const *, std::size_t);
OutputType operator "" _suffix(char16_t const *, std::size_t);
OutputType operator "" _suffix(char32_t const *, std::size_t);

OutputType operator "" _suffix(char const *, std::size_t);

OutputType operator "" _suffix(wchar_t const *, std::size_t);

OutputType operator "" _suffix(char16_t const *, std::size_t);

OutputType operator "" _suffix(char32_t const *, std::size_t);

Raw literals

Raw literals are supported only for integral and floating point types. The literal operator called for a cooked literal has following form (notice that the operator does not take a second parameter to indicate the size, the string is null-terminated):

OutputType operator "" _suffix(const char*);

1	OutputType operator "" _suffix(const char*);

Parsing this array of characters may involve loops, variable declaration, function calls, etc. As a result this form of the literal operator cannot be constexpr, which means it cannot be evaluated at compile time.

An alternative way of processing raw literals is with a literal operator variadic template. The purpose of a variadic template literal operator is to make the literal transformation at compile time. The form of the literal operator template is:

template<char...> OutputType operator "" _tuffix();

1	template<char...> OutputType operator "" _tuffix();

A bit of practice

Let’s take the following example where we declare a buffer of 4 KB.

std::array<unsigned char, 4_KB> buffer;

1	std::array<unsigned char, 4_KB> buffer;

This is identical to the following declaration (you’d usually expect)

std::array<unsigned char, 4096> buffer;

1	std::array<unsigned char, 4096> buffer;

It is made possible by the existence of a literal operator with the following form:

constexpr size_t operator "" _KB(unsigned long long size)
{
   return static_cast<size_t>(size * 1024);
}

constexpr size_t operator "" _KB(unsigned long long size)

{

return static_cast<size_t>(size * 1024);

}

If the literal operator was not a constexpr then the compiler would trigger an error when declaring the buffer variable, because the size of the array must be known at compile time. You’d still be able to use the user-defined literal but in runtime contexts, such as sizing a vector.

std::vector<unsigned char> buffer(4_KB);

1	std::vector<unsigned char> buffer(4_KB);

In the next example we define a user-defined literal for expressing temperatures in Fahrenheit degrees. Supposing the Celsius degrees are the norm, we can write sometime like this:

constexpr long double operator"" _fah(long double const degrees)
{
   return (degrees - 32.0) / 1.8;
}

constexpr long double operator"" _fah(long double const degrees)

{

return (degrees - 32.0) / 1.8;

}

and use it like in the following example:

auto threshold = 77.0_fah;
auto temp = 0.0;
std::cout << "Input temperature (in Celsius):";
std::cin >> temp;

std::cout << (temp < threshold ? "cold" : "warm") << std::endl;

auto threshold = 77.0_fah;

auto temp = 0.0;

std::cout << "Input temperature (in Celsius):";

std::cin >> temp;

std::cout << (temp < threshold ? "cold" : "warm") << std::endl;

The return type of the literal operator can be any type; it does not have to be a built-in type like in the previous examples. Given the following hierarchy of classes we can create user-defined literals that enable the creation of developer and quality assurer objects:

class Employee
{
   std::string name;
public:
   Employee(std::string const & name) :name(name){}
   std::string getName() const { return name; }
};

class Developer : public Employee
{
public:
   using Employee::Employee;
};

class QualityAssurer : public Employee
{
public:
   using Employee::Employee;
};

Developer operator "" _dev(char const * text, std::size_t const size)
{
   return Developer(std::string(text, text + size));
}

QualityAssurer operator "" _qa(char const * text, std::size_t const size)
{
   return QualityAssurer(std::string(text, text + size));
}

int main()
{
   auto d = "marius"_dev;
   auto q = "john"_qa;
   std::cout << d.getName() << std::endl;
   std::cout << q.getName() << std::endl;

   return 0;
}

class Employee

{

std::string name;

public:

Employee(std::string const & name) :name(name){}

std::string getName() const { return name; }

};

class Developer : public Employee

{

public:

using Employee::Employee;

};

class QualityAssurer : public Employee

{

public:

using Employee::Employee;

};

Developer operator "" _dev(char const * text, std::size_t const size)

{

return Developer(std::string(text, text + size));

}

QualityAssurer operator "" _qa(char const * text, std::size_t const size)

{

return QualityAssurer(std::string(text, text + size));

}

int main()

{

auto d = "marius"_dev;

auto q = "john"_qa;

std::cout << d.getName() << std::endl;

std::cout << q.getName() << std::endl;

return 0;

}

In the next example we want to express latitudes, such as 66°33’39”N (the Arctic Circle). (Notice that the following types and just some simple implementations for demo purposes only).

class GeoCoordinate
{
protected:
   double degrees;
   double minutes;
   double seconds;
public:
   constexpr GeoCoordinate(double const degrees, double const minutes, double const seconds)
      :degrees(degrees), minutes(minutes), seconds(seconds)
   {}

   GeoCoordinate& operator+=(GeoCoordinate const & other)
   {
      seconds += other.seconds;
      minutes += other.minutes;
      degrees += other.degrees;

      return *this;
   }

   friend GeoCoordinate operator+(GeoCoordinate lhs, GeoCoordinate const & rhs)
   {
      return lhs += rhs;
   }

   double get_degrees() const { return degrees; }
   double get_minutes() const { return minutes; }
   double get_seconds() const { return seconds; }
};

enum class LatitudeDirection
{
   Undefined,
   North,
   South,
};

class Latitude : public GeoCoordinate
{
   LatitudeDirection direction;
public:
   constexpr Latitude(double const degree, double const minutes, double const seconds, LatitudeDirection const dir = LatitudeDirection::Undefined)
      :GeoCoordinate(degree, minutes, seconds), direction(dir)
   {}

   Latitude& operator+=(Latitude const & other)
   {
      if (direction == other.direction || direction == LatitudeDirection::Undefined || other.direction == LatitudeDirection::Undefined)
      {
         seconds += other.seconds;
         minutes += other.minutes;
         degrees += other.degrees;

         if (direction == LatitudeDirection::Undefined)
         {
            direction = other.direction;
         }
      }
      else
         throw std::exception("Invalid latitude direction");

      return *this;
   }

   friend Latitude operator+(Latitude lhs, Latitude const & rhs)
   {
      return lhs += rhs;
   }

   friend Latitude operator+(Latitude lhs, LatitudeDirection dir)
   {
      if (lhs.direction != LatitudeDirection::Undefined &&
         lhs.direction != dir)
         throw std::exception("Invalid latitude direction");

      Latitude l = lhs;
      l.direction = dir;
      return l;
   }
};

Latitude operator+(GeoCoordinate lhs, LatitudeDirection dir)
{
   return Latitude(lhs.get_degrees(), lhs.get_minutes(), lhs.get_seconds(), dir);
}

class GeoCoordinate

{

protected:

double degrees;

double minutes;

double seconds;

public:

constexpr GeoCoordinate(double const degrees, double const minutes, double const seconds)

:degrees(degrees), minutes(minutes), seconds(seconds)

{}

GeoCoordinate& operator+=(GeoCoordinate const & other)

{

seconds += other.seconds;

minutes += other.minutes;

degrees += other.degrees;

return *this;

}

friend GeoCoordinate operator+(GeoCoordinate lhs, GeoCoordinate const & rhs)

{

return lhs += rhs;

}

double get_degrees() const { return degrees; }

double get_minutes() const { return minutes; }

double get_seconds() const { return seconds; }

};

enum class LatitudeDirection

{

Undefined,

North,

South,

};

class Latitude : public GeoCoordinate

{

LatitudeDirection direction;

public:

constexpr Latitude(double const degree, double const minutes, double const seconds, LatitudeDirection const dir = LatitudeDirection::Undefined)

:GeoCoordinate(degree, minutes, seconds), direction(dir)

{}

Latitude& operator+=(Latitude const & other)

{

if (direction == other.direction || direction == LatitudeDirection::Undefined || other.direction == LatitudeDirection::Undefined)

{

seconds += other.seconds;

minutes += other.minutes;

degrees += other.degrees;

if (direction == LatitudeDirection::Undefined)

{

direction = other.direction;

}

else

throw std::exception("Invalid latitude direction");

return *this;

}

friend Latitude operator+(Latitude lhs, Latitude const & rhs)

{

return lhs += rhs;

}

friend Latitude operator+(Latitude lhs, LatitudeDirection dir)

{

if (lhs.direction != LatitudeDirection::Undefined &&

lhs.direction != dir)

throw std::exception("Invalid latitude direction");

Latitude l = lhs;

l.direction = dir;

return l;

}

};

Latitude operator+(GeoCoordinate lhs, LatitudeDirection dir)

{

return Latitude(lhs.get_degrees(), lhs.get_minutes(), lhs.get_seconds(), dir);

}

With this in place we can create objects like this:

auto g1 = GeoCoordinate(66, 0, 0);
auto g2 = GeoCoordinate(0, 33, 0);
auto g3 = GeoCoordinate(0, 0, 39);
auto g4 = g1 + g2 + g3;
auto g5 = GeoCoordinate(66, 0, 0) + GeoCoordinate(0, 33, 0) + GeoCoordinate(0, 0, 39);

auto l1 = Latitude(66, 0, 0, LatitudeDirection::North);
auto l2 = Latitude(0, 33, 0);
auto l3 = Latitude(0, 0, 39);
auto l4 = l1 + l2 + l3;

auto l5 = Latitude(66, 0, 0, LatitudeDirection::North) + Latitude(0, 33, 0) + Latitude(0, 0, 39);
auto l6 = Latitude(66, 0, 0) + Latitude(0, 33, 0) + Latitude(0, 0, 39) + LatitudeDirection::North;
auto l7 = GeoCoordinate(66, 0, 0) + GeoCoordinate(0, 33, 0) + GeoCoordinate(0, 0, 39) + LatitudeDirection::North;

auto g1 = GeoCoordinate(66, 0, 0);

auto g2 = GeoCoordinate(0, 33, 0);

auto g3 = GeoCoordinate(0, 0, 39);

auto g4 = g1 + g2 + g3;

auto g5 = GeoCoordinate(66, 0, 0) + GeoCoordinate(0, 33, 0) + GeoCoordinate(0, 0, 39);

auto l1 = Latitude(66, 0, 0, LatitudeDirection::North);

auto l2 = Latitude(0, 33, 0);

auto l3 = Latitude(0, 0, 39);

auto l4 = l1 + l2 + l3;

auto l5 = Latitude(66, 0, 0, LatitudeDirection::North) + Latitude(0, 33, 0) + Latitude(0, 0, 39);

auto l6 = Latitude(66, 0, 0) + Latitude(0, 33, 0) + Latitude(0, 0, 39) + LatitudeDirection::North;

auto l7 = GeoCoordinate(66, 0, 0) + GeoCoordinate(0, 33, 0) + GeoCoordinate(0, 0, 39) + LatitudeDirection::North;

Values like Latitude(66, 0, 0) are not very intuitive. Even though it’s more verbose it may be more desirable to be able to create objects like this:

auto lat = deg(66) + min(33) + sec(39) + LatitudeDirection::North;

1	auto lat = deg(66) + min(33) + sec(39) + LatitudeDirection::North;

That is possible if we define deg(), min() and sec() as following:

constexpr GeoCoordinate deg(double value)
{
   return GeoCoordinate(value, 0, 0);
}

constexpr GeoCoordinate min(double value)
{
   return GeoCoordinate(0, value, 0);
}

constexpr GeoCoordinate sec(double value)
{
   return GeoCoordinate(0, 0, value);
}

constexpr GeoCoordinate deg(double value)

{

return GeoCoordinate(value, 0, 0);

}

constexpr GeoCoordinate min(double value)

{

return GeoCoordinate(0, value, 0);

}

constexpr GeoCoordinate sec(double value)

{

return GeoCoordinate(0, 0, value);

}

User-defined literals makes is more simple and more natural. By transforming the above functions into literal operators we can simplify the syntax.

constexpr GeoCoordinate operator "" _deg(long double value)
{
   return GeoCoordinate(value, 0, 0);
}

constexpr GeoCoordinate operator "" _min(long double value)
{
   return GeoCoordinate(0, value, 0);
}

constexpr GeoCoordinate operator "" _sec(long double value)
{
   return GeoCoordinate(0, 0, value);
}

constexpr GeoCoordinate operator "" _deg(long double value)

{

return GeoCoordinate(value, 0, 0);

}

constexpr GeoCoordinate operator "" _min(long double value)

{

return GeoCoordinate(0, value, 0);

}

constexpr GeoCoordinate operator "" _sec(long double value)

{

return GeoCoordinate(0, 0, value);

}

As a result we can now create latitudes like this:

auto lat = 66.0_deg + 33.0_min + 39.0_sec + LatitudeDirection::North;

1	auto lat = 66.0_deg + 33.0_min + 39.0_sec + LatitudeDirection::North;

It should be very simple to develop this to support longitudes. You don’t have to add more literal operators, just the Longitude type and the appropriate overloaded operators for it.

Standard user-defined literals

C++14 defines several literal operators:

operator""if, operator""i and operator""il for creating a std::complex value

C++

#include <complex> int main() { using namespace std::literals::complex_literals; std::complex<double> c = 1.0 + 2i; }

1
2
3
4
5
6
7

#include <complex>

int main()
{
using namespace std::literals::complex_literals;
std::complex<double> c = 1.0 + 2i;
}
operator""h, operator""min, operator""s, operator""ms, operator""us, operator""ns for creating a std::chrono::duration value

C++

#include <chrono> int main() { using namespace std::literals::chrono_literals; auto timer = 1h + 30min + 30s; // duration 01:30:30 }

1
2
3
4
5
6
7

#include <chrono>

int main()
{
using namespace std::literals::chrono_literals;
auto timer = 1h + 30min + 30s; // duration 01:30:30
}

This is equivalent to the following (longer) form in C++11:

C++

auto timer = std::chrono::hours(1) + std::chrono::minutes(30) + std::chrono::seconds(30);

1

auto timer = std::chrono::hours(1) + std::chrono::minutes(30) + std::chrono::seconds(30);
operator""s for converting a character array literal to a std::basic_string

C++

int main() { using namespace std::string_literals; std::string s1 = "text\0"; // s1 = "text" std::string s2 = "text\0"s; // s2 = "text\0" }

1
2
3
4
5
6

int main()
{
   using namespace std::string_literals;
   std::string s1 = "text\0";  // s1 = "text"
   std::string s2 = "text\0"s; // s2 = "text\0"
}

Notice that all these literal operators are defined in separate namespaces that you have to use.

References

Compiler support

User defined literals are supported by major compilers starting with the following version:

GCC: 4.7
Clang: 3.1
VC++: v13 (Visual Studio 2014)

Function return type deduction in C++14

1 Reply

C++11 introduced the auto keyword as a placeholder for types. It could be used for declaring variables but also for the return type of a function, given than you use a new syntax with a trailing type at the end of the function.

auto foo() -> int 
{
   return 42;
}

auto foo() -> int

{

return 42;

}

template <typename T>
auto foo(T value) -> decltype(value.bar())
{
   return value.bar();
}

template <typename T>

auto foo(T value) -> decltype(value.bar())

{

return value.bar();

}

This is a bit cumbersome and too explicit so C++14 takes the next step and makes the trailing return type unnecessary. Under C++14 the above examples can be simply written as:

auto foo()
{
   return 42;
}

auto foo()

{

return 42;

}

and

template <typename T>
auto foo(T value)
{
   return value.bar();
}

template <typename T>

auto foo(T value)

{

return value.bar();

}

There are several things to keep in mind:

if a function has more than one return statement they all must deduce the same type

C++

auto foo() { if(condition) return 1; return 0; }

1
2
3
4
5
6
7

auto foo()
{
  if(condition)
     return 1;

  return 0;
}
a recursive function can have an auto return type only if it has a non-recursive return statement before the recursive call.

C++

auto fibonacci(int n) { if(n<=2) return 1; else return fibonacci(n-1) + fibonacci(n-2); }

1
2
3
4
5

auto fibonacci(int n)
{
if(n<=2) return 1;
else return fibonacci(n-1) + fibonacci(n-2);
}
a function with an auto return type can be forward declared, but cannot be used until it has been defined

In my personal opinion auto return type should be used with caution. It can make the code harder to read and maintain (you don’t know the type just by looking at the signature), harder to document (automatic documenting tools use the signature to produce documentation), and can lead to situations when the developer expects one return type but the compiler generates another.

Additional readings:

Farewell to new and delete

2 Replies

C++11 introduced several smart pointers (residing in the <memory> header):

std::shared_ptr: retains shared ownership of an object, that is destroyed when the last shared_ptr that holds a reference to it is destroyed or assigned another pointer.
std::unique_ptr: retains sole ownership of an object, that is destroyed when the unique_ptr goes out of scope
std::weak_ptr: retains a non-owning reference to an object managed by a shared_ptr. It does not participate in the reference counter of the shared pointer. It is mainly use to break circular dependencies.

std::shared_ptr<int> p1(new int(42));
std::shared_ptr<int> p2(p1);
std::weak_ptr<int> w1 = p1;
std::unique_ptr<int> u1(new int(42));

std::shared_ptr<int> p1(new int(42));

std::shared_ptr<int> p2(p1);

std::weak_ptr<int> w1 = p1;

std::unique_ptr<int> u1(new int(42));

While these smart pointers manage resources automatically, so there is no need to delete object explicitly, they still require explicit instantiation with new for the managed resource.

C++11 introduced std::make_shared, a free function that constructs an object and wraps it in a std::shared_ptr object.

auto p1 = std::make_shared<int>(42);

1	auto p1 = std::make_shared<int>(42);

C++14 introduces another free function, std::make_unique, that constructs an object and wraps it in a std::unique_ptr object.

auto u1 = std::make_unique<int>(42);

1	auto u1 = std::make_unique<int>(42);

With these smart pointer and functions available there is no need any more to use new and delete in your C++ code. Besides avoiding explicit allocation and release these functions have another important advantage: they prevent memory leaks that could happen in the context of function calls. You can read Herb Sutter’s GotW #102: Exception-Safe Function Calls for details about this problem.

codexpert blog

I see native code

Tag Archives: C++14

Codexpert – 2015 Articles Summary

Microsoft Libraries and C++ Programming Language

What’s next?

See also

Like this:

Binary literals and digit separators

Like this:

Using Lambdas in MFC Applications – Part 1: Sorting Arrays

Sorting CStringArray by using a lambda expression

Using decltype to sort any type of MFC array

Using generic (polymorphic) lambda expressions

Notes

References and related articles

Like this:

User defined literals

A bit of theory

Cooked literals

Raw literals

A bit of practice

Standard user-defined literals

References

Compiler support

See also:

Like this:

Function return type deduction in C++14

Like this:

Farewell to new and delete

Like this:

Microsoft Libraries and C++ Programming Language

What’s next?

See also

Share this:

Like this:

Share this:

Like this:

Sorting CStringArray by using a lambda expression

Using decltype to sort any type of MFC array

Using generic (polymorphic) lambda expressions

Notes

References and related articles

Share this:

Like this:

A bit of theory

Cooked literals

Raw literals

A bit of practice

Standard user-defined literals

References

Compiler support

See also:

Share this:

Like this:

Share this:

Like this:

Share this:

Like this: