CppCon Call for Poster Submissions
This year, CppCon will, for the first time, have poster presentations. The call for poster submissions has just been released.
The Call for Poster Submissions
Quick Q: Being smart with smart pointers: avoiding shared_ptr overuse
Quick A: Use unique_ptr when you can.
Recently on SO:
Being smart with smart pointers: avoiding shared_ptr overuse
To allow
unique_ptr/shared_ptr, you may use template:// Dispatcher for make_unique/make_shared template <template <typename...> class Ptr, typename T> struct make_helper; template <typename T> struct make_helper<std::unique_ptr, T> { template <typename ...Ts> std::unique_ptr<T> operator() (Ts&&... args) const { return std::make_unique<T>(std::forward<Ts>(args)...); } }; template <typename T> struct make_helper<std::shared_ptr, T> { template <typename ...Ts> std::shared_ptr<T> operator() (Ts&&... args) const { return std::make_shared<T>(std::forward<Ts>(args)...); } }; template <template <typename...> class Ptr, typename T, typename ... Ts> auto make(Ts&&... args) { return make_helper<Ptr, T>{}(std::forward<Ts>(args)...); }And then
bool get_resource_parameters(Param1& param1,..., ParamN& paramN) { //... } template <template <typename...> class Ptr> Ptr<resource> open_resource(...) { Param1 param1; ... ParamN paramN; if(!get_resource_parameters(param1, ..., paramN)) return nullptr; return = make<Ptr, resource>(param1, ..., paramN); }And check for
nullptrinstead of splitboolandsmart_pointer.
RAII versus Exceptions--Arne Mertz
There is no fight, is there?
RAII versus Exceptions
by Arne Mertz
From the article:
Recently I received a question on Twitter whether to prefer RAII over Exceptions. I have seen similar questions being asked again and again over time, so there seems to be some need for clarification...
CppCon 2015 C++ Metaprogramming: A Paradigm Shift--Louis Dionne
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
C++ Metaprogramming: A Paradigm Shift
by Louis Dionne
Summary of the talk:
Most people think metaprogramming is hard. It isn't; we just didn't have the right tools for it. This talk will present a new way of metaprogramming using the same syntax as that of normal C++. It will show how the runtime and the compile-time boundaries can be crossed almost seamlessly. It will show how compilation times can be reduced without sacrificing expressiveness. It will introduce Hana [1], a newly accepted Boost library using cutting edge features of the language in a creative way to solve the problem of metaprogramming for good.
C++ Weekly Episode 12: C+17's std::any -- Jason Turner
Episode 12 of C++ Weekly.
C++17's std::any
by Jason Turner
About the show:
In this episode Jason introduces std::any from the upcoming proposed C++17 standard.
James McNellis' talks @Italian C++ Conference 2016
The talks James McNellis gave at the Italian C++ Conference 2016 are now online:
An Introduction to C++ Coroutines
One of the most interesting new features being proposed for C++ standardization is coroutines, formerly known as “resumable functions.” C++ coroutines are designed to be highly scalable, highly efficient (no overhead), and highly extensible, while still interacting seamlessly with the rest of the C++ language.
This session will consist of an in-depth introduction to C++ coroutines. We will begin by looking at the rationale for adding coroutines to the C++ language and then look at several examples that show [1] how to write a coroutine, [2] how to use the extensibility model to adapt existing libraries to work with C++ coroutines, and [3] how coroutines really work “under the hood,” using the Visual C++ implementation as a reference. Finally, we will look briefly at the status of the C++ coroutines proposal and some of the competing ideas.
Adventures in a Legacy Codebase
Three years ago, the Visual C++ team undertook a project to substantially modernize and redesign the Microsoft C Runtime (CRT) with the goals of improving long-term maintainability, performance, and usability. This work culminated with the release of the Universal CRT with Windows 10 and Visual Studio 2015.
In this session, I will discuss our team’s experiences from this project. We’ll look at some of the techniques we used in modernizing a decades-old codebase and look at some of the challenges that we faced, lessons that we learned, and best practices that we developed during the course of the project.
Conference Submission Deadlines--Jon Kalb
Some deadlines are close!
Conference Submission Deadlines
by Jon Kalb
An Overview of Static Analyzers for C/C++ Code--Aleksandr Alekseev
Which static tools do you use?
An Overview of Static Analyzers for C/C++ Code
by Aleksandr Alekseev
From the article:
C and C++ programmers tend to make mistakes when writing code.
Many of these mistakes can be found using -Wall, asserts, tests, meticulous code review, IDE warnings, building with different compilers for different operating systems running on different hardware configurations, and the like. But even all these means combined often fail to reveal all the bugs. Static code analysis helps improve the situation a little. In this post, we will take a look at some static analysis tools. [The author of this article is not an employee of our company, and his opinion may be different from ours.]...
CppCon 2015 Faster Complex Numbers--André Bergner
Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:
Faster Complex Numbers
by André Bergner
Summary of the talk:
Complex numbers are an important tool from mathematics enabling many problems to be written in a more generic form. The C++ standard library comes with an implementation to work with complex numbers in a natural way.
Motivated by useful real world examples from theoretical physics and audio dsp I will discuss benchmarks of std::complex and demonstrate how alternative implementations, naïve or advanced ones based on expression templates, outperform std::complex and can compete with hand-crafted C code (depending on compiler and std lib). A quick introduction to expression templates will be provided.
Italian C++ Conference 2016--Marco Arena
A brief article on the first edition of:
Italian C++ Conference 2016
by Marco Arena
From the article:
After two years of meetups and participations in Italy, last Saturday we had more than 100 people attending (130+ registered people – ~22% drop) the first edition of the Italian C++ Conference, in Milan, our new free event fully focused on C++. Hosted by “Bicocca” University and sponsored by RogueWave Software, we delivered 5×60′ technical sessions, 1×30′ sponsor demo session and 1×40′ Q/A panel. It has been a great day!...