Category Archives: C++

Codexpert – 2016 Articles Summary

C++ Programming Language

Microsoft Libraries

Visual C++

Guidelines Support Library Review: string_span<T>

In a previous post I have introduced the span<T> type from the Guidelines Support Library. This is a non-owning range of contiguous memory recommended to be used instead of pointers (and size counter) or standard containers (such as vector or array). span<T> can be used with strings, but the Guidelines Support Library provides a different span implementation for various types of strings. These string span types are available in the string_span.h header.

String span types

There are several string span types defined in the string_span.h header:

basic_string_span: the actual implementation for a string span on which several type aliases are available:

string_span: a string span of char
cstring_span: a string span of const char
wstring_span: a string span of wchar_t
cwstring_span: a string span of const wchar_t

template<std::ptrdiff_t Extent = dynamic_range>
using string_span = basic_string_span<char, Extent>;

template<std::ptrdiff_t Extent = dynamic_range>
using cstring_span = basic_string_span<const char, Extent>;

template<std::ptrdiff_t Extent = dynamic_range>
using wstring_span = basic_string_span<wchar_t, Extent>;

template<std::ptrdiff_t Extent = dynamic_range>
using cwstring_span = basic_string_span<const wchar_t, Extent>;

template<std::ptrdiff_t Extent = dynamic_range>

using string_span = basic_string_span<char, Extent>;

template<std::ptrdiff_t Extent = dynamic_range>

using cstring_span = basic_string_span<const char, Extent>;

template<std::ptrdiff_t Extent = dynamic_range>

using wstring_span = basic_string_span<wchar_t, Extent>;

template<std::ptrdiff_t Extent = dynamic_range>

using cwstring_span = basic_string_span<const wchar_t, Extent>;

basic_zstring_span: a null terminated string span used for converting null terminated spans to legacy strings; it has several type aliases available:

zstring_span: a null terminated string span of char
czstring_span: a null terminated string span of const char
wzstring_span: a null terminated string span of wchar_t
cwzstring_span: a null terminated string span of const wchar_t

template <std::ptrdiff_t Max = dynamic_range>
using zstring_span = basic_zstring_span<char, Max>;

template <std::ptrdiff_t Max = dynamic_range>
using wzstring_span = basic_zstring_span<wchar_t, Max>;

template <std::ptrdiff_t Max = dynamic_range>
using czstring_span = basic_zstring_span<const char, Max>;

template <std::ptrdiff_t Max = dynamic_range>
using cwzstring_span = basic_zstring_span<const wchar_t, Max>;

template <std::ptrdiff_t Max = dynamic_range>

using zstring_span = basic_zstring_span<char, Max>;

template <std::ptrdiff_t Max = dynamic_range>

using wzstring_span = basic_zstring_span<wchar_t, Max>;

template <std::ptrdiff_t Max = dynamic_range>

using czstring_span = basic_zstring_span<const char, Max>;

template <std::ptrdiff_t Max = dynamic_range>

using cwzstring_span = basic_zstring_span<const wchar_t, Max>;

These look like a lot of classes with similar names, but the names are self explanatory (terminology is c=const, w=wide, z=null-terminated):

string: a string of char
cstring: a string of const char
wstring: a string of wchar_t
cwstring: a string of const wchar_t
zstring: a (zero) null-terminated string of char
czstring: a null-terminated string of const char
wzstring: a null-terminated string of wchar_t
cwzstring: a null-terminated string of const wchar_t

Creating a string_span

A string_span can be created in many ways, including:

(Note that in all following examples the string span is the range { L'H',L'e',L'l',L'l',L'o',L' ',L'w',L'o',L'r',L'l',L'd' } of either char or wchar_t.)

from a literal string

C++

gsl::cstring_span<> s1 = gsl::ensure_z("Hello world"); gsl::cwstring_span<> s2 = gsl::ensure_z(L"Hello world");

1
2
3

gsl::cstring_span<> s1 = gsl::ensure_z("Hello world");

gsl::cwstring_span<> s2 = gsl::ensure_z(L"Hello world");
from a pointer

C++

const char* t1 = "Hello world"; gsl::cstring_span<> s1 = gsl::ensure_z(t1); const wchar_t* t2 = L"Hello world"; gsl::cwstring_span<> s2 = gsl::ensure_z(t2);

1
2
3
4
5

const char* t1 = "Hello world";
gsl::cstring_span<> s1 = gsl::ensure_z(t1);

const wchar_t* t2 = L"Hello world";
gsl::cwstring_span<> s2 = gsl::ensure_z(t2);
from a standard string

C++

std::string str1 = "Hello world"; gsl::cstring_span<> s1 = str1; std::wstring wstr1 = L"Hello world"; gsl::cwstring_span<> s2 = wstr1;

1
2
3
4
5

std::string str1 = "Hello world";
gsl::cstring_span<> s1 = str1;

std::wstring wstr1 = L"Hello world";
gsl::cwstring_span<> s2 = wstr1;
from an array

C++

char a1[] = "Hello world"; gsl::cstring_span<> s1 = gsl::ensure_z(a1); wchar_t a2[] = L"Hello world"; gsl::cwstring_span<> s2 = gsl::ensure_z(a2);

1
2
3
4
5

char a1[] = "Hello world";
gsl::cstring_span<> s1 = gsl::ensure_z(a1);

wchar_t a2[] = L"Hello world";
gsl::cwstring_span<> s2 = gsl::ensure_z(a2);

from a vector

std::vector<char> vec1 = { 'H','e','l','l','o',' ','w','o','r','l','d' };
gsl::string_span<> s1 = vec1;

std::vector<wchar_t> vec2 = { L'H',L'e',L'l',L'l',L'o',L' ',L'w',L'o',L'r',L'l',L'd' };
gsl::wstring_span<> s2 = vec2;

std::vector<char> vec1 = { 'H','e','l','l','o',' ','w','o','r','l','d' };

gsl::string_span<> s1 = vec1;

std::vector<wchar_t> vec2 = { L'H',L'e',L'l',L'l',L'o',L' ',L'w',L'o',L'r',L'l',L'd' };

gsl::wstring_span<> s2 = vec2;

Converting to string

To convert a string span into a string you can use the to_string() function.

char a1[] = "Hello world";
gsl::cstring_span<> s1 = gsl::ensure_z(a1);
std::string str1 = gsl::to_string(s1);   // str1 = "Hello world"

wchar_t a2[] = L"Hello world";
gsl::cwstring_span<> s2 = gsl::ensure_z(a2);
std::wstring str2 = gsl::to_string(s2);  // str2 = L"Hello world"

char a1[] = "Hello world";

gsl::cstring_span<> s1 = gsl::ensure_z(a1);

std::string str1 = gsl::to_string(s1); // str1 = "Hello world"

wchar_t a2[] = L"Hello world";

gsl::cwstring_span<> s2 = gsl::ensure_z(a2);

std::wstring str2 = gsl::to_string(s2); // str2 = L"Hello world"

Size of a string_span

Unlike span<T>, a string_span<T> only have one dimension, so the rank() method does not make make sense and is not available. However, a string span has several methods for the size of the span:

size() and length(): return the number of elements of the span
size_bytes() and length_bytes(): return the number of bytes of the span

std::string str1 = "Hello world";
gsl::cstring_span<> s1 = str1;

std::cout << "length=" << s1.length() << std::endl;              // length=11
std::cout << "size=" << s1.size() << std::endl;                  // size=11

std::cout << "length bytes=" << s1.length_bytes() << std::endl;  // length bytes=11
std::cout << "size bytes=" << s1.size_bytes() << std::endl;      // size bytes=11

std::wstring str2 = L"Hello world";
gsl::cwstring_span<> s2 = str2;

std::cout << "length=" << s2.length() << std::endl;              // length=11
std::cout << "size=" << s2.size() << std::endl;                  // size=11

std::cout << "length bytes=" << s2.length_bytes() << std::endl;  // length bytes=22
std::cout << "size bytes=" << s2.size_bytes() << std::endl;      // size bytes=22

std::string str1 = "Hello world";

gsl::cstring_span<> s1 = str1;

std::cout << "length=" << s1.length() << std::endl; // length=11

std::cout << "size=" << s1.size() << std::endl; // size=11

std::cout << "length bytes=" << s1.length_bytes() << std::endl; // length bytes=11

std::cout << "size bytes=" << s1.size_bytes() << std::endl; // size bytes=11

std::wstring str2 = L"Hello world";

gsl::cwstring_span<> s2 = str2;

std::cout << "length=" << s2.length() << std::endl; // length=11

std::cout << "size=" << s2.size() << std::endl; // size=11

std::cout << "length bytes=" << s2.length_bytes() << std::endl; // length bytes=22

std::cout << "size bytes=" << s2.size_bytes() << std::endl; // size bytes=22

Subspans

It is possible to create subspans from a string_span. There are several functions that do that:

first(): returns the sub-span with the first N elements from the original string_span
last(): returns the sub-span with the last N elements from the original string_span
subspan(): returns the sub-span within the specified range (first and last positions) of the original string_span.

std::string str1 = "Hello world";
gsl::cstring_span<> s1 = str1;            // s1 = { 'H','e','l','l','o',' ','w','o','r','l','d' }
gsl::cstring_span<> l = s1.first(5);      // l = { 'H','e','l','l','o' }
gsl::cstring_span<> r = s1.last(5);       // r = { 'w','o','r','l','d' }
gsl::cstring_span<> m = s1.subspan(3, 5); // m = { 'l','o',' ','w','o' }

std::string str1 = "Hello world";

gsl::cstring_span<> s1 = str1; // s1 = { 'H','e','l','l','o',' ','w','o','r','l','d' }

gsl::cstring_span<> l = s1.first(5); // l = { 'H','e','l','l','o' }

gsl::cstring_span<> r = s1.last(5); // r = { 'w','o','r','l','d' }

gsl::cstring_span<> m = s1.subspan(3, 5); // m = { 'l','o',' ','w','o' }

Comparisons

You can use the comparison operators (==, !=, <, <=, >, >=) with two string spans. Just like in the case of span<T>, equality is checked with std::equal (two ranges are equal if every element in the first range is equal to the element corresponding to the same position in the second range) and less/greater is checked with std::lexicographical_compare() (one range is less than another if the first mismatch element in the first range is less than the element on the same position in the second range).

std::string str1 = "Hello world";
gsl::cstring_span<> s1 = str1;

std::string str2 = "Hello world!";
gsl::cstring_span<> s2 = str2;

std::cout << (s1 == s2) << std::endl; // prints 0
std::cout << (s1 != s2) << std::endl; // prints 1
std::cout << (s1 < s2)  << std::endl; // prints 1
std::cout << (s1 > s2)  << std::endl; // prints 0

std::string str1 = "Hello world";

gsl::cstring_span<> s1 = str1;

std::string str2 = "Hello world!";

gsl::cstring_span<> s2 = str2;

std::cout << (s1 == s2) << std::endl; // prints 0

std::cout << (s1 != s2) << std::endl; // prints 1

std::cout << (s1 < s2) << std::endl; // prints 1

std::cout << (s1 > s2) << std::endl; // prints 0

Element access

It is possible to access the content of a string_span either with iterators or indexes.

std::string str = "Hello world";
gsl::cstring_span<> s = str;

// prints Hello world
for (auto const & e : s) std::cout << e;
std::cout << std::endl;

// prints dlrow olleH
for (auto it = s.rbegin(); it != s.rend(); ++it) std::cout << *it;
std::cout << std::endl;

// prints Hello world
for (auto it = std::begin(s); it != std::end(s); ++it) std::cout << *it;
std::cout << std::endl;

// prints Hello world
for (ptrdiff_t i = 0; i < s.size(); ++i)
    std::cout << s[i];
std::cout << std::endl;

//s[5] = '-'; // Error	C3892	's': you cannot assign to a variable that is const

std::string str = "Hello world";

gsl::cstring_span<> s = str;

// prints Hello world

for (auto const & e : s) std::cout << e;

std::cout << std::endl;

// prints dlrow olleH

for (auto it = s.rbegin(); it != s.rend(); ++it) std::cout << *it;

std::cout << std::endl;

// prints Hello world

for (auto it = std::begin(s); it != std::end(s); ++it) std::cout << *it;

std::cout << std::endl;

// prints Hello world

for (ptrdiff_t i = 0; i < s.size(); ++i)

std::cout << s[i];

std::cout << std::endl;

//s[5] = '-'; // Error C3892 's': you cannot assign to a variable that is const

std::string str = "Hello world";
gsl::string_span<> s = str;

s[5] = '-';

// prints Hello-world
for (ptrdiff_t i = 0; i < s.size(); ++i)
   std::cout << s[i];
std::cout << std::endl;

std::string str = "Hello world";

gsl::string_span<> s = str;

s[5] = '-';

// prints Hello-world

for (ptrdiff_t i = 0; i < s.size(); ++i)

std::cout << s[i];

std::cout << std::endl;

Guidelines Support Library Review: span<T>

5 Replies

The Guidelines Support Library is a Microsoft implementation of some of the types and functions described in the C++ Core Guidelines maintained by the Standard C++ Foundation. Among the types provided by the GSL is span<T> formerly known as array_view<T>. This article is an introduction to this type.

span<T> is a non-owning range of contiguous memory recommended to be used instead of pointers (and size counter) or standard containers (such as std::vector or std::array).

Suppose you want to create a function that displays the content of a container. Such a function could look like this:

template <typename T>
void display(std::vector<T> const & data)
{
   for (auto const e : data) std::cout << e << ' ';
   std::cout << std::endl;
}

std::vector<int> v{ 1, 2, 3, 4, 5 };
display(v);

template <typename T>

void display(std::vector<T> const & data)

{

for (auto const e : data) std::cout << e << ' ';

std::cout << std::endl;

}

std::vector<int> v{ 1, 2, 3, 4, 5 };

display(v);

This will work with vectors, but not with arrays or lists. So then you need overloads in order to support other containers.

template <class Iterator>
void display(Iterator const b, Iterator const e)
{
   for (Iterator i = b; i != e; ++i) std::cout << *i << ' ';
   std::cout << std::endl;
}

template <typename T>
void display(std::vector<T> const & data)
{
   display(std::begin(data), std::end(data));
}

template <typename T, size_t S>
void display(std::array<T, S> const & data)
{
   display(std::begin(data), std::end(data));
}

std::vector<int> v{ 1, 2, 3, 4, 5 };
display(v);

std::array<int, 5> a{1, 2, 3, 4, 5};
display(a);

template <class Iterator>

void display(Iterator const b, Iterator const e)

{

for (Iterator i = b; i != e; ++i) std::cout << *i << ' ';

std::cout << std::endl;

}

template <typename T>

void display(std::vector<T> const & data)

{

display(std::begin(data), std::end(data));

}

template <typename T, size_t S>

void display(std::array<T, S> const & data)

{

display(std::begin(data), std::end(data));

}

std::vector<int> v{ 1, 2, 3, 4, 5 };

display(v);

std::array<int, 5> a{1, 2, 3, 4, 5};

display(a);

But what if you now what to display the content of an int[] or an int*?

The span<T> type is intended as a uniform interface over arrays, pointers and standard containers that can be used as a replacement of these types. It does not store a copy of the original data, only a pointer to data and counters.

template <typename T>
void display(gsl::span<T> const & data)
{
   for(auto const e : data) std::cout << e << ' ';
   std::cout << std::endl;
}

std::vector<int> v{ 1, 2, 3, 4, 5 };
gsl::span<int> s1{ v };
display(s1);

std::array<int, 5> a{1, 2, 3, 4, 5};
gsl::span<int> s2{ a };
display(s2);

int arr[] = { 1, 2, 3, 4, 5 };
gsl::span<int> s3{ arr };
display(s3);

template <typename T>

void display(gsl::span<T> const & data)

{

for(auto const e : data) std::cout << e << ' ';

std::cout << std::endl;

}

std::vector<int> v{ 1, 2, 3, 4, 5 };

gsl::span<int> s1{ v };

display(s1);

std::array<int, 5> a{1, 2, 3, 4, 5};

gsl::span<int> s2{ a };

display(s2);

int arr[] = { 1, 2, 3, 4, 5 };

gsl::span<int> s3{ arr };

display(s3);

The following helper functions are used in the samples below:

template <class Iterator>
void show(Iterator b, Iterator e)
{
   for (auto i = b; i != e; ++i)
   {
      std::cout << *i << ' ';
   }
   std::cout << std::endl;
}

template <class T>
void show(gsl::span<T> const & s)
{
   show(std::begin(s), std::end(s));
}

template <class T, size_t R>
void show(gsl::span<T, R> const & s)
{
   show(std::begin(s), std::end(s));
}

template <class T, size_t R, size_t C>
void show(gsl::span<T, R, C> const & s)
{
   show(std::begin(s), std::end(s));
}

template <class T, size_t R, size_t C>
void show(gsl::span<T, gsl::dynamic_range, R, C> const & s)
{
   show(std::begin(s), std::end(s));
}

template <class Iterator>

void show(Iterator b, Iterator e)

{

for (auto i = b; i != e; ++i)

{

std::cout << *i << ' ';

}

std::cout << std::endl;

}

template <class T>

void show(gsl::span<T> const & s)

{

show(std::begin(s), std::end(s));

}

template <class T, size_t R>

void show(gsl::span<T, R> const & s)

{

show(std::begin(s), std::end(s));

}

template <class T, size_t R, size_t C>

void show(gsl::span<T, R, C> const & s)

{

show(std::begin(s), std::end(s));

}

template <class T, size_t R, size_t C>

void show(gsl::span<T, gsl::dynamic_range, R, C> const & s)

{

show(std::begin(s), std::end(s));

}

Creating a span

A span can be created in many ways, including:

from a single value (variable, not a literal)

C++

int n = 1; gsl::span<int> s1 = n; // s1 = {1} gsl::span<int, 1> s2 = n; // se = {1}

1
2
3

int n = 1;
gsl::span<int> s1 = n; // s1 = {1}
gsl::span<int, 1> s2 = n; // se = {1}

from a pointer and number of elements

std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
gsl::span<int>    s1(v.data(), 4); // s1 = {1, 2, 3, 4}
gsl::span<int, 4> s2(v.data(), 4); // s2 = {1, 2, 3, 4}

std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

gsl::span<int> s1(v.data(), 4); // s1 = {1, 2, 3, 4}

gsl::span<int, 4> s2(v.data(), 4); // s2 = {1, 2, 3, 4}

from a begin and end pointer

std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
gsl::span<int>    s1(&v[0], &v[4]); // s1 = {1, 2, 3, 4}
gsl::span<int, 4> s2(&v[0], &v[4]); // s2 = {1, 2, 3, 4}

std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

gsl::span<int> s1(&v[0], &v[4]); // s1 = {1, 2, 3, 4}

gsl::span<int, 4> s2(&v[0], &v[4]); // s2 = {1, 2, 3, 4}

from a C-like array

int arr[] = { 1, 2, 3, 4, 5 };
gsl::span<int>    s1{ arr }; // s1 = {1, 2, 3, 4, 5}
gsl::span<int, 5> s2{ arr }; // s2 = {1, 2, 3, 4, 5}

int arr2[2][3] = {1, 2, 3, 4, 5, 6};
gsl::span<int>       s3{ arr2 }; // s3 = {1, 2, 3, 4, 5, 6}
gsl::span<int, 6>    s4{ arr2 }; // s3 = {1, 2, 3, 4, 5, 6}
gsl::span<int, 2, 3> s5{ arr2 }; // s3 = {1, 2, 3, 4, 5, 6}

int arr[] = { 1, 2, 3, 4, 5 };

gsl::span<int> s1{ arr }; // s1 = {1, 2, 3, 4, 5}

gsl::span<int, 5> s2{ arr }; // s2 = {1, 2, 3, 4, 5}

int arr2[2][3] = {1, 2, 3, 4, 5, 6};

gsl::span<int> s3{ arr2 }; // s3 = {1, 2, 3, 4, 5, 6}

gsl::span<int, 6> s4{ arr2 }; // s3 = {1, 2, 3, 4, 5, 6}

gsl::span<int, 2, 3> s5{ arr2 }; // s3 = {1, 2, 3, 4, 5, 6}

from a dynamic array

int (*arr)[3][3] = new int[2][3][3];
for (int i = 0; i < 2; ++i)
{
   for (int j = 0; j < 3; j++)
   {
      for (int k = 0; k < 3; ++k)
      {
         arr[i][j][k] = k + j * 3 + i * 9;
      }
   }
}

gsl::span<int, gsl::dynamic_range, 3, 4> s1{ arr, 2 };
show(s1);  // prints 0 1 2 3 4 .. 17

delete[] arr;

int (*arr)[3][3] = new int[2][3][3];

for (int i = 0; i < 2; ++i)

{

for (int j = 0; j < 3; j++)

{

for (int k = 0; k < 3; ++k)

{

arr[i][j][k] = k + j * 3 + i * 9;

}

gsl::span<int, gsl::dynamic_range, 3, 4> s1{ arr, 2 };

show(s1); // prints 0 1 2 3 4 .. 17

delete[] arr;

from a standard container with contiguous memory layout such as array, vector or string

std::array<int, 5> a = { 1, 2, 3, 4, 5 };
gsl::span<int>    s1{ a }; // s1 = {1, 2, 3, 4, 5, 6}
gsl::span<int, 5> s2{ a }; // s2 = {1, 2, 3, 4, 5, 6}

std::vector<int> v = { 1, 2, 3, 4, 5 };
gsl::span<int>    s3{ v }; // s3 = {1, 2, 3, 4, 5, 6}
gsl::span<int, 5> s4{ v }; // s4 = {1, 2, 3, 4, 5, 6}

std::string text = "sample";
gsl::span<const char> s5{ text }; // s5 = {'s', 'a', 'm', 'p', 'l', 'e'}

std::array<int, 5> a = { 1, 2, 3, 4, 5 };

gsl::span<int> s1{ a }; // s1 = {1, 2, 3, 4, 5, 6}

gsl::span<int, 5> s2{ a }; // s2 = {1, 2, 3, 4, 5, 6}

std::vector<int> v = { 1, 2, 3, 4, 5 };

gsl::span<int> s3{ v }; // s3 = {1, 2, 3, 4, 5, 6}

gsl::span<int, 5> s4{ v }; // s4 = {1, 2, 3, 4, 5, 6}

std::string text = "sample";

gsl::span<const char> s5{ text }; // s5 = {'s', 'a', 'm', 'p', 'l', 'e'}

using the gsl::as_span() function:

std::vector<int> v = { 1, 2, 3, 4, 5 };
auto sv = gsl::as_span(v);  // sv = {1, 2, 3, 4, 5}

std::array<int, 5> a = { 1, 2, 3, 4, 5 };
auto sa = gsl::as_span(a);  // sa = {1, 2, 3, 4, 5}

std::vector<int> v = { 1, 2, 3, 4, 5 };

auto sv = gsl::as_span(v); // sv = {1, 2, 3, 4, 5}

std::array<int, 5> a = { 1, 2, 3, 4, 5 };

auto sa = gsl::as_span(a); // sa = {1, 2, 3, 4, 5}

Notice that it is not possible to create a span from an initializer_list because an initializer list is a temporary object and a span is a non-owning container, it does not make a copy of the data, and therefore it can end up containing dangling references to temporary data. For a detailed discussion on the topic see this issue.

Size of a span

A span can have zero, one or more dimensions, and each dimension can have a different size (number of elements). The number of dimensions is called rank and the number of elements in a dimension is called extent. You can retrieve the rank and extent using the functions with the same name.

gsl::span<int> s0{ nullptr }; // rank = 1, extent[0] = 0
gsl::span<int> s1;            // rank = 1, extent[0] = 0 

int arr[] = { 1, 2, 3, 4, 5 };
gsl::span<int> s2{ arr };     // rank = 1, extent[0] = 5
gsl::span<int, 5> s3{ arr };  // rank = 1, extent[0] = 5

std::cout << "rank=" << s2.rank() << std::endl;           // rank=1
std::cout << "extent(0)=" << s2.extent(0) << std::endl;   // extent[0]=5
std::cout << "extent<0>=" << s2.extent<0>() << std::endl; // extent[0]=5

gsl::span<int, 2, 3> s4{ arr, 6 }; // rank = 2, extent[0] = 2, extent[1] = 3

std::cout << "rank=" << s4.rank() << std::endl;           // rank=2
std::cout << "extent(0)=" << s4.extent(0) << std::endl;   // extent[0]=2
std::cout << "extent(1)=" << s4.extent(1) << std::endl;   // extent[1]=3

gsl::span<int> s0{ nullptr }; // rank = 1, extent[0] = 0

gsl::span<int> s1; // rank = 1, extent[0] = 0

int arr[] = { 1, 2, 3, 4, 5 };

gsl::span<int> s2{ arr }; // rank = 1, extent[0] = 5

gsl::span<int, 5> s3{ arr }; // rank = 1, extent[0] = 5

std::cout << "rank=" << s2.rank() << std::endl; // rank=1

std::cout << "extent(0)=" << s2.extent(0) << std::endl; // extent[0]=5

std::cout << "extent<0>=" << s2.extent<0>() << std::endl; // extent[0]=5

gsl::span<int, 2, 3> s4{ arr, 6 }; // rank = 2, extent[0] = 2, extent[1] = 3

std::cout << "rank=" << s4.rank() << std::endl; // rank=2

std::cout << "extent(0)=" << s4.extent(0) << std::endl; // extent[0]=2

std::cout << "extent(1)=" << s4.extent(1) << std::endl; // extent[1]=3

Subspans

It is possible to create subspans from a span. There are several functions that do that:

first(): returns the sub-span with the first N elements from the original span
last(): returns the sub-span with the last N elements from the original span
subspan(): returns the sub-span within the specified range (first and last positions) of the original span.

int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
gsl::span<int> s{ arr };

auto fs1 = s.first(0);        // fs1 = {}
auto fs2 = s.first(5);        // fs2 = {1, 2, 3, 4, 5}
auto fs3 = s.first<3>();      // fs3 = {1, 2, 3}

auto ls1 = s.last(0);         // ls1 = {}
auto ls2 = s.last(5);         // ls2 = {6, 7, 8, 9, 10} 
auto ls3 = s.last<3>();       // ls3 = {8, 9, 10}

auto ns1 = s.subspan(0, 0);   // ns1 = {}
auto ns2 = s.subspan(0, 5);   // ns2 = {1, 2, 3, 4, 5}
auto ns3 = s.subspan(5, 0);   // ns3 = {}
auto ns4 = s.subspan<0, 0>(); // ns4 = {}
auto ns5 = s.subspan<0, 5>(); // ns5 = {1, 2, 3, 4, 5}
auto ns6 = s.subspan<5, 0>(); // ns6 = {}

int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

gsl::span<int> s{ arr };

auto fs1 = s.first(0); // fs1 = {}

auto fs2 = s.first(5); // fs2 = {1, 2, 3, 4, 5}

auto fs3 = s.first<3>(); // fs3 = {1, 2, 3}

auto ls1 = s.last(0); // ls1 = {}

auto ls2 = s.last(5); // ls2 = {6, 7, 8, 9, 10}

auto ls3 = s.last<3>(); // ls3 = {8, 9, 10}

auto ns1 = s.subspan(0, 0); // ns1 = {}

auto ns2 = s.subspan(0, 5); // ns2 = {1, 2, 3, 4, 5}

auto ns3 = s.subspan(5, 0); // ns3 = {}

auto ns4 = s.subspan<0, 0>(); // ns4 = {}

auto ns5 = s.subspan<0, 5>(); // ns5 = {1, 2, 3, 4, 5}

auto ns6 = s.subspan<5, 0>(); // ns6 = {}

Comparisons

You can use the comparison operators (==, !=, <, <=, >, >=) with two spans. Equality is checked with std::equal (two ranges are equal if every element in the first range is equal to the element corresponding to the same position in the second range) and less/greater is checked with std::lexicographical_compare() (one range is less than another if the first mismatch element in the first range is less than the element on the same position in the second range).

int arr1[2][3] = { 1, 2, 3, 4, 5, 6 };
gsl::span<int, 6> s1{ arr1 };

int arr2[] = { 1, 2, 3, 4, 5, 6 };
gsl::span<int> s2{ arr2 };

int arr3[] = { 1, 2, 3 };
gsl::span<int> s3{ arr3 };

int arr4[] = { 3, 2, 1 };
gsl::span<int> s4{ arr4 };

std::cout << (s1 == s2) << std::endl; // prints 1
std::cout << (s2 == s3) << std::endl; // prints 0
std::cout << (s2 > s3)  << std::endl; // prints 1
std::cout << (s4 != s3) << std::endl; // prints 1
std::cout << (s4 > s3)  << std::endl; // prints 1

int arr1[2][3] = { 1, 2, 3, 4, 5, 6 };

gsl::span<int, 6> s1{ arr1 };

int arr2[] = { 1, 2, 3, 4, 5, 6 };

gsl::span<int> s2{ arr2 };

int arr3[] = { 1, 2, 3 };

gsl::span<int> s3{ arr3 };

int arr4[] = { 3, 2, 1 };

gsl::span<int> s4{ arr4 };

std::cout << (s1 == s2) << std::endl; // prints 1

std::cout << (s2 == s3) << std::endl; // prints 0

std::cout << (s2 > s3) << std::endl; // prints 1

std::cout << (s4 != s3) << std::endl; // prints 1

std::cout << (s4 > s3) << std::endl; // prints 1

Element access

It is possible to access the content of a span either with iterators or indexes.

std::vector<int> v = { 1, 2, 3, 4, 5, 6 };
gsl::span<int> s{ v };

// prints 1 2 3 4 5 6
for (auto const & e : s) std::cout << e << std::endl;
// prints 6 5 4 3 2 1
for (auto it = s.rbegin(); it != s.rend(); ++it) std::cout << *it << std::endl;
// prints 1 2 3 4 5 6
for (auto it = std::begin(s); it != std::end(s); ++it) std::cout << *it << std::endl;

std::vector<int> v = { 1, 2, 3, 4, 5, 6 };

gsl::span<int> s{ v };

// prints 1 2 3 4 5 6

for (auto const & e : s) std::cout << e << std::endl;

// prints 6 5 4 3 2 1

for (auto it = s.rbegin(); it != s.rend(); ++it) std::cout << *it << std::endl;

// prints 1 2 3 4 5 6

for (auto it = std::begin(s); it != std::end(s); ++it) std::cout << *it << std::endl;

When it comes to index access you can either index like a regular array (s[0], s[1][2], etc.) or using a special type called index.

std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
gsl::span<int> s1{ v };
gsl::span<int, 3, 4> s2{ v };

// prints 1 2 3 ... 12
for (int i = 0; i < s1.extent(0); ++i) 
   std::cout << s1[i] << ' ';
std::cout << std::endl;

// prints 
// 1 2 3 4
// 5 6 7 8
// 9 10 11 12
for (int i = 0; i < s2.extent(0); ++i)
{
   for (int j = 0; j < s2.extent(1); ++j)
      std::cout << s2[i][j] << ' ';
   std::cout << std::endl;
}

// uni-dimensional index
gsl::index<1> i1 = { 0 };
std::cout << s1[i1] << std::endl;  // prints 1

// bi-dimensional index
gsl::index<2> i2 = { 1, 1 };
std::cout << s2[i2] << std::endl;  // prints 6

// bi-dimensional index computed from another index
gsl::index<2> i3 = i2 * 2; 
std::cout << s2[i3] << std::endl;  // prints 11

std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

gsl::span<int> s1{ v };

gsl::span<int, 3, 4> s2{ v };

// prints 1 2 3 ... 12

for (int i = 0; i < s1.extent(0); ++i)

std::cout << s1[i] << ' ';

std::cout << std::endl;

// prints

// 1 2 3 4

// 5 6 7 8

// 9 10 11 12

for (int i = 0; i < s2.extent(0); ++i)

{

for (int j = 0; j < s2.extent(1); ++j)

std::cout << s2[i][j] << ' ';

std::cout << std::endl;

}

// uni-dimensional index

gsl::index<1> i1 = { 0 };

std::cout << s1[i1] << std::endl; // prints 1

// bi-dimensional index

gsl::index<2> i2 = { 1, 1 };

std::cout << s2[i2] << std::endl; // prints 6

// bi-dimensional index computed from another index

gsl::index<2> i3 = i2 * 2;

std::cout << s2[i3] << std::endl; // prints 11

Codexpert – 2015 Articles Summary

1 Reply

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.

Using Lambdas in MFC Applications – Part 3: Dealing with C++ REST SDK

1 Reply

C++ REST SDK (also known as Casablanca) offers support for HTTP client/server, JSON, URI, asynchronous streams, WebSockets client, oAuth and PPL Tasks.
We can get C++ REST SDK from CodePlex or use the one shipped with Visual Studio 2013.
This article gives suggestions of how to set up a Visual C++ project (particularly one that uses MFC) in order to be able to deal with Casablanca library. It also shows some simple sample code and a demo MFC project.

Set up the project for using C++ REST SDK

First, must find the location where C++ REST SDK is installed. With Visual Studio 2013 installed, I found it in the following path:
C:\Program Files (x86)\Microsoft SDKs\Cpp REST SDK for Visual Studio 2013\SDK\ which is similar to $(ExtensionSDKDirectoryRoot)\Cpp REST SDK for Visual Studio 2013\SDK.
Next, create a new MFC project or open an existing one, right click on it’s name, choose “Properties” from the context menu, then do the following:

Choose All configurations in the Configuration combo box.
Go to Configuration Properties / C/C++ / General and add $(ExtensionSDKDirectoryRoot)\Cpp REST SDK for Visual Studio 2013\SDK\include to Additional Include Directories list.
Go to Configuration Properties / C/C++ / Command Line and add -Zm200 in Additional Options field; this is necessary to avoid C3859 compiler error when include Casablanca headers in stdafx.h.
Go to Configuration Properties / Linker / General and add $(ExtensionSDKDirectoryRoot)\Cpp REST SDK for Visual Studio 2013\SDK\lib\$(PlatformTarget)\$(Configuration) to Additional Library Directories list.
Go to Configuration Properties / Linker / Input and add casablanca120.lib to Additional Dependencies.
Also in Configuration Properties / Linker / Input add casablanca120.dll to Delay Loaded DLLs list; this is necessary to avoid false memory leaks reported by the MFC framework;
Go to Configuration Properties / Build Events / Post-Build Event and add the following command to Command Line field
copy /Y “$(ExtensionSDKDirectoryRoot)\Cpp REST SDK for Visual Studio 2013\SDK\bin\$(PlatformTarget)\$(Configuration)\casablanca120.dll” “$(OutDir)”; this copies the necessary Casablanca DLL from its install folder in the output directory of our project.
Close the project property pages dialog.
In stdafx.h include all necesary Casablanca headers, e.g. http_client.h, json.h, pplxtasks.h and so on.

Now, we are ready to go on and use C++ REST SDK stuff in our own MFC application.

Notes

Remember that other versions of Visual Studio may install C++ REST SDK in other location!
May be other methods to set up the project paths, as for example by using Property Manager and/or edit .props files; I just presented one presumed simpler.
Ones would prefer to get C++ REST SDK from CodePlex; probably, I’ll describe this alternative in a future article.

Next is some code sample. You can notice it uses lambda expressions and for that reason I included this article in Using Lambdas in MFC Applications series.

Using lambdas and C++ REST SDK with MFC – sample code

This sample sends a JSON structure in URI query part to a site which gives in response also a JSON which says if the sent one is valid or not and gives an error description if necessary.

void CJsonVerifierDlg::OnClickButtonVerifyJson()
{
    UpdateData();

    try
    {
        auto task = _VerifyJsonTask();
        task.wait();
        auto spJsonValue = task.get();
        if (spJsonValue)
            _DisplayResponse(spJsonValue);
    }
    catch (std::exception& e)
    {
        CString strMessage;
        strMessage.Format(L"Exception: %S", e.what());
        AfxMessageBox(strMessage, MB_ICONERROR);
    }
}

void CJsonVerifierDlg::OnClickButtonVerifyJson()

{

UpdateData();

try

{

auto task = _VerifyJsonTask();

task.wait();

auto spJsonValue = task.get();

if (spJsonValue)

_DisplayResponse(spJsonValue);

}

catch (std::exception& e)

{

CString strMessage;

strMessage.Format(L"Exception: %S", e.what());

AfxMessageBox(strMessage, MB_ICONERROR);

}

pplx::task<std::shared_ptr<web::json::value>> CJsonVerifierDlg::_VerifyJsonTask()
{
    return pplx::create_task([this]()
        {
            // base URI
            auto sBaseURI = utility::string_t(m_strBaseURI.GetString());
            // build request URI
            auto sRequestURI = web::http::uri_builder()
                .append_query(L"json", m_strInputJson.GetString()).to_string();
            // create http client
            web::http::client::http_client httpClient(sBaseURI);
            // create GET http request
            web::http::http_request httpRequest(U("GET")); //web::http::methods::GET);
            // set request URI
            httpRequest.set_request_uri(sRequestURI);
            // send request
            return httpClient.request(httpRequest);
            // then receive the response
        }).then([](web::http::http_response httpResponse)
            {
                std::shared_ptr<web::json::value> spJsonValue;
                if (web::http::status_codes::OK == httpResponse.status_code())
                {
                    spJsonValue = 
                        std::make_shared<web::json::value>(httpResponse.extract_json().get());
                }
                return spJsonValue;
            });
}

pplx::task<std::shared_ptr<web::json::value>> CJsonVerifierDlg::_VerifyJsonTask()

{

return pplx::create_task([this]()

{

// base URI

auto sBaseURI = utility::string_t(m_strBaseURI.GetString());

// build request URI

auto sRequestURI = web::http::uri_builder()

.append_query(L"json", m_strInputJson.GetString()).to_string();

// create http client

web::http::client::http_client httpClient(sBaseURI);

// create GET http request

web::http::http_request httpRequest(U("GET")); //web::http::methods::GET);

// set request URI

httpRequest.set_request_uri(sRequestURI);

// send request

return httpClient.request(httpRequest);

// then receive the response

}).then([](web::http::http_response httpResponse)

{

std::shared_ptr<web::json::value> spJsonValue;

if (web::http::status_codes::OK == httpResponse.status_code())

{

spJsonValue =

std::make_shared<web::json::value>(httpResponse.extract_json().get());

}

return spJsonValue;

});

}

void CJsonVerifierDlg::_DisplayResponse(const std::shared_ptr<web::json::value>& spJsonValue)
{
    if ((*spJsonValue)[U("validate")].as_bool())
    {
        m_strIsValid = _T("YES");
        m_nParseTime = (*spJsonValue)[U("parse_time_nanoseconds")].as_integer();
    }
    else
    {
        m_strIsValid = _T("NO");
        m_strError = (*spJsonValue)[U("error")].as_string().c_str();
    }
    UpdateData(FALSE);
}

void CJsonVerifierDlg::_DisplayResponse(const std::shared_ptr<web::json::value>& spJsonValue)

{

if ((*spJsonValue)[U("validate")].as_bool())

{

m_strIsValid = _T("YES");

m_nParseTime = (*spJsonValue)[U("parse_time_nanoseconds")].as_integer();

}

else

{

m_strIsValid = _T("NO");

m_strError = (*spJsonValue)[U("error")].as_string().c_str();

}

UpdateData(FALSE);

}

More details about project settings and source code can be found in the attached demo project.

Using lambdas and C++ REST SDK with MFC – demo project

Download: JSON Verifier - Demo Application using Casablanca.zip (690)

JSON Verifier – Demo Application using Casablanca

References and related articles

CodePlex: C++ REST SDK
MSDN: C++ REST SDK (Codename “Casablanca”)
Marius Bancila’s Blog: C++ REST SDK in Visual Studio 2013
Visual C++ Team Blog: The C++ REST SDK (“Casablanca”)
Dr. Dobb’s: Using the Microsoft C++ REST SDK
Codexpert Blog: Using Lambdas in MFC Applications – Part 1: Sorting Arrays
Codexpert Blog: Using Lambdas in MFC Applications – Part 2: Replacing Callback Functions
Codexpert Blog: C++11: Let’s Write a “Hello Lambda!”

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 2: Replacing Callback Functions

Enumerate windows using “classic” callback functions

Usually, for that purpose we declare and implement as callback, a static member function having the signature required by EnumWindows in its first argument.

class CDemoDlg : public CDialog
{
    // ...

    static BOOL CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lParam);    
};

class CDemoDlg : public CDialog

{

// ...

static BOOL CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lParam);

};

BOOL CALLBACK CDemoDlg::EnumWindowsProc(HWND hWnd, LPARAM lParam)
{
    CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);
    // do something, e.g. add the found window handle to a list
    return TRUE; // continue the enumeration
}

void CDemoDlg::OnButtonEnumWindows()
{
    ::EnumWindows(&CDemoDlg::EnumWindowsProc, reinterpret_cast<LPARAM>(this));
}

BOOL CALLBACK CDemoDlg::EnumWindowsProc(HWND hWnd, LPARAM lParam)

{

CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);

// do something, e.g. add the found window handle to a list

return TRUE; // continue the enumeration

}

void CDemoDlg::OnButtonEnumWindows()

{

::EnumWindows(&CDemoDlg::EnumWindowsProc, reinterpret_cast<LPARAM>(this));

}

Notes

CALLBACK is defined in Windows SDK as __stdcall.

Enumerate windows using lambda expressions

The same result can be achieved by using a lambda expression. This is somehow simpler because does not require to declare and define a static member function.

void CDemoDlg::OnButtonEnumWindows()
{
    // in the first parameter of EnumWindows, pass a lambda expression
    ::EnumWindows([](HWND hWnd, LPARAM lParam) -> BOOL
    {
        CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);
        // do something, e.g. push the found window handle in a list.
        return TRUE; // continue the enumeration
    }, 
    reinterpret_cast<LPARAM>(this)); // second parameter of EnumWindows
}

void CDemoDlg::OnButtonEnumWindows()

{

// in the first parameter of EnumWindows, pass a lambda expression

::EnumWindows([](HWND hWnd, LPARAM lParam) -> BOOL

{

CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);

// do something, e.g. push the found window handle in a list.

return TRUE; // continue the enumeration

reinterpret_cast<LPARAM>(this)); // second parameter of EnumWindows

}

Notes

as stated in the introduction, there is not necessary to explicitly convert the lambda expression to the function pointer required by EnumWindowsProc (WNDENUMPROC);
as stated in the introduction, there is not possible to capture neither local variables, nor this pointer; luckily, like in many other WinAPI callbacks, we can pass the necessary stuff in a parameter of type LPARAM or LPVOID.

Using nested lambda expressions

Let’s say we want to enumerate the top-level windows in a worker thread. We can write something like this:

void CDemoDlg::OnButtonEnumWindows()
{
    AfxBeginThread([](LPVOID lpParam) -> UINT
    {
        ::EnumWindows([](HWND hWnd, LPARAM lParam) -> BOOL
        {
            CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);
            // do something, e.g. push the found window handle in a list
            return TRUE; // continue the enumeration
        }, 
            reinterpret_cast<LPARAM>(lpParam)); // second parameter of EnumWindows
        return 0;
    },
        reinterpret_cast<LPVOID>(this));  // second parameter of AfxBeginThread
}

void CDemoDlg::OnButtonEnumWindows()

{

AfxBeginThread([](LPVOID lpParam) -> UINT

{

::EnumWindows([](HWND hWnd, LPARAM lParam) -> BOOL

{

CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);

// do something, e.g. push the found window handle in a list

return TRUE; // continue the enumeration

reinterpret_cast<LPARAM>(lpParam)); // second parameter of EnumWindows

return 0;

reinterpret_cast<LPVOID>(this)); // second parameter of AfxBeginThread

}

We have passed lambdas both for callback parameter of AfxBeginThread and EnumWindows. EnumWindows is called in the first lambda body and takes a lambda as well.
This compiles with no problem in x64 builds, but may give a conversion error for the inner lambda in Win32 ones. That’s a little glitch which AFAIK has been fixed in Visual Studio 2015.
However, to be sure it compiles also in Visual Studio 2012/2013 – Win32 builds, we can simply cast explicitly the inner lambda.

void CDemoDlg::OnButtonEnumWindows()
{
    AfxBeginThread([](LPVOID lpParam) -> UINT
    {
        ::EnumWindows(static_cast<WNDENUMPROC>([](HWND hWnd, LPARAM lParam) -> BOOL
        {
            CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);
            // do something, e.g. push the found window handle in a list
            return TRUE; // continue the enumeration
        }), 
            reinterpret_cast<LPARAM>(lpParam)); // second parameter of EnumWindows
        return 0;
    },
        reinterpret_cast<LPVOID>(this));  // second parameter of AfxBeginThread
}

void CDemoDlg::OnButtonEnumWindows()

{

AfxBeginThread([](LPVOID lpParam) -> UINT

{

::EnumWindows(static_cast<WNDENUMPROC>([](HWND hWnd, LPARAM lParam) -> BOOL

{

CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam);

// do something, e.g. push the found window handle in a list

return TRUE; // continue the enumeration

}),

reinterpret_cast<LPARAM>(lpParam)); // second parameter of EnumWindows

return 0;

reinterpret_cast<LPVOID>(this)); // second parameter of AfxBeginThread

}

Notes

x64 builds has no __stdcall calling convention; __stdcall keyword is still accepted but simply ignored by the compiler.
of course, we can use lambda expressions in the same way also in ATL applications or C++ programs that use plain WinAPI.

Resources and related articles

ISO/IEC 14882 Third Edition: 5.1.2 Lambda expressions
Visual C++ Team Blog: C++11 Features in Visual C++ 11
MSDN: What’s New for Visual C++ in Visual Studio 2012
Codexpert blog: Using Lambdas in MFC Applications – Part 1: Sorting Arrays
Codexpert blog: C++11: Let’s Write a “Hello Lambda!”

C++ Programming Language

Microsoft Libraries

Visual C++

See also

Share this:

Like this:

String span types

Creating a string_span

Converting to string

Size of a string_span

Subspans

Comparisons

Element access

Share this:

Like this:

Creating a span

Size of a span

Subspans

Comparisons

Element access

Share this:

Like this:

Microsoft Libraries and C++ Programming Language

What’s next?

See also

Share this:

Like this:

Set up the project for using C++ REST SDK

Notes

Using lambdas and C++ REST SDK with MFC – sample code

Using lambdas and C++ REST SDK with MFC – demo project

References and related articles

Share this:

Like this:

Share this:

Like this:

Enumerate windows using “classic” callback functions

Notes

Enumerate windows using lambda expressions

Notes

Using nested lambda expressions

Notes

Resources and related articles

Share this:

Like this: