The main() Course -- Adi Shavit
A fanciful little post about li’l old main().
The main() Course
by Adi Shavit
From the article:
The function main() is a normal program’s entry point.
The shortest conforming C++ executable program is: int main(){}
CppCon 2016: What We've Learned From the C++ Community--Robert Irving & Jason Turner
Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:
What We've Learned From the C++ Community
by Robert Irving & Jason Turner
Summary of the talk:
For over a year and a half Rob and Jason have been engaging with the speakers, library authors, bloggers and luminaries of the C++ community for their podcast, CppCast. In this talk they'll share the most interesting tools, insights and lessons they have learned from interviewing and interacting with the C++ community
CppCast Episode 116: Volta and Cuda C++ with Olivier Giroux
Episode 116 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Olivier Giroux from NVidia to talk about programming for the Volta GPU.
CppCast Episode 116: Volta and Cuda C++ with Olivier Giroux
by Rob Irving and Jason Turner
About the interviewee:
Olivier Giroux has worked on eight GPU and four SM architecture generations released by NVIDIA. Lately, he works to clarify the forms and semantics of valid GPU programs, present and future. He was the programming model lead for the new NVIDIA Volta architecture. He is a member of WG21, the ISO C++ committee, and is a passionate contributor to C++'s forward progress guarantees and memory model.
Just C++ - dlib serialize & std::shared_ptr
New episode of Just C++, today on serializing shared_ptr with dlib
Just C++ - serializing dlib & std::shared_ptr
by Jens Weller
Visual Studio extensions for C++ developers in Visual Studio 2017--Adam Welch
Several Visual Studio extensions that can make your life better as a C++ developer:
Visual Studio extensions for C++ developers in Visual Studio 2017
by Adam Welch
From the article:
In this blogpost we want to highlight several Visual Studio extensions that can make your life better as a C++ developer if you’re using Visual Studio 2017 or considering upgrading...
Just C++ - dlib overview
New Just C++ episode, this time with an overview on dlib
Just C++ - dlib overview
by Jens Weller
C++ Weekly Episode 78: Intro to CMake—Jason Turner
Episode 78 of C++ Weekly.
Intro to CMake
by Jason Turner
About the show:
In this episode Jason gives an overview on how to use CMake for crossplatform C++ development.
Quick Q: Array Initialisation Compile Time - Constexpr Sequence
Quick A: Use integer_sequence with a helper function.
Recently on SO:
Array Initialisation Compile Time - Constexpr Sequence
1) How to implement that kind of integer_sequence?
template <std::size_t... Is> constexpr auto make_sequence_impl(std::index_sequence<Is...>) { return std::index_sequence<generate_ith_number(Is)...>{}; } template <std::size_t N> constexpr auto make_sequence() { return make_sequence_impl(std::make_index_sequence<N>{}); }2) Is it possible to build an std::array from that integer_sequence at compile time?
template <std::size_t... Is> constexpr auto make_array_from_sequence_impl(std::index_sequence<Is...>) { return std::array<std::size_t, sizeof...(Is)>{Is...}; } template <typename Seq> constexpr auto make_array_from_sequence(Seq) { return make_array_from_sequence_impl(Seq{}); }Usage:
int main() { constexpr auto arr = make_array_from_sequence(make_sequence<6>()); static_assert(arr[0] == 0); static_assert(arr[1] == 1); static_assert(arr[2] == 2); static_assert(arr[3] == 4); static_assert(arr[4] == 5); static_assert(arr[5] == 7); }
Quick Q: vector of vector does not convert brace encloser list
Quick A: The constructor needs an extra {} pair.
Recently on SO:
vector does not convert brace encloser list
You have two options:
- add a constructor taking
std::initializer_list<std::initializer_list<T>>- eclose the init expression with another set of
{}i.e.Matrix<double> a{{ { 17, 24, 1}, { 23, 5, 7 }, { 4, 6, 13 } }};Ok, I'll try a little explanation of what is going on here:
If there is no constructor taking a
std::initializer_listthen the outermost{}are always opening and closing the constructor call if you will, and not part of what you actually pass to the constructor.Matrix<double> a{ {1, 2}, {3, 4} }; ^ ^~~~~~~~~~~~~~ ^ | 2 parameters | | | | | opening closingAs you can see this is taken as a constructor with 2 parameters, in this case 2
initializer_lists.This is why you need another set of
{}:Matrix<double> a{ {{1, 2}, {3, 4}} }; ^ ^~~~~~~~~~~~~~~~ ^ | 1 parameter | | | | | opening closingIn order for the outermost
{}to be considered aninitializer_listthen the constructor needs to have an overload taking ainitializer_list. That is what is happening in thestd::vectorcase.
CppCon 2016: The Exception Situation--Patrice Roy
Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2016 for you to enjoy. Here is today’s feature:
The Exception Situation
by Patrice Roy
Summary of the talk:
Exceptions have been a part of C++ for a long time now, and they are not going away. They allow programmers to concentrate on the meaningful parts of their code and treat the things that happen infrequently as… well, exceptional situations, to be dealt with when and where the context makes it reasonable or useful.
On the other hand, some significant parts of the C++ programming community either dislike this mechanism or outright reject it, for a number of reasons. Work in SG14 has raised performance issues in some cases; there are those who dislike the additional execution paths introduced in programs that rely on exceptions; some programmers raised issues with respect to exceptions and tooling, integration with older codebases, writing robust generic code, etc.
This talk will be neither for not against exceptions. It will present a perspective on cases where they make sense, cases where they are less appropriate, alternative disappointment handling techniques presented along with client code in order to show how the various approaches influence the way code is written. Performance measurements will be given along the way. Some creative uses of exceptions will also be presented in order to spark ideas and discussions in the room.