: Standard C++

Home » Blog » Categories »

« Prev Next »

CppCon 2023 Plug-in Based Software Architecture for Robotics -- Abishalini Sivaraman

By Blog Staff | Sep 10, 2023 02:54 PM | Tags: None

Registration is now open for CppCon 2023! The conference starts on October 1 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2023!

Plug-in Based Software Architecture for Robotics

Monday, October 2 • 16:45 - 17:15

by Abishalini Sivaraman

Abishalini Sivaraman holds a bachelors and masters degree in electrical and computer engineering from Texas A&M University. She has worked on various robotics projects as part of school and work in the last 5 years.

CppCon 2023 Thinking Functionally in C++ -- Brian Ruth

By Blog Staff | Sep 9, 2023 02:48 PM | Tags: None

Thinking Functionally in C++

Monday, October 2 • 15:15 - 16:15

by Brian Ruth

Summary of the talk:

C++ is a multi-paradigm language, supporting OO, procedural and functional programming styles. Functional languages conjure up thoughts of academic languages; immutable data and mathematical terms like monad and higher order functions. We’ve been told of the advantages of functional languages, specifically when it comes to parallelization and safety, but very few of them are ever used in production code. However, what if we were to take the mindset of functional programming and apply it to existing C++ codebases? How will it change the way we write and think about our code? In this talk, we will explore ways to think functionally about your code and how to modify it using functional techniques. We will explore some of the additions C++ has made to aid in functional programming in the form of views, lambdas and ranges and how those fit into an existing OO or procedural codebase. We will finish up by looking at functional design considerations and their tradeoffs. After leaving this talk you should have the tools to identify instances in your code where using functional thinking will improve its performance, reusability and security.

CppCon 2023 C++ Modules: Getting Started Today -- Andreas Weis

By Blog Staff | Sep 8, 2023 02:45 PM | Tags: None

C++ Modules: Getting Started Today

Monday, October 2 • 15:15 - 16:15

by Andreas Weis

Summary of the talk:

Modules have been one of the most highly anticipated features of C++20. Unfortunately, it was also the language feature that took the longest to become widely available for developers to use. This year, for the first time, we see broad support for the feature in all major compilers and mainstream build system support through CMake. The goal of this talk is to provide you with all the basic knowledge to allow you getting started with C++20 modules today.

We will take a look at how modules change the build process and why it took so long to implement them. We will take a tour of the essentials of the named modules mechanism and explore the new best practices for physical code structure in a modules-based code base, including how to set up a build with CMake. And last but not least, we will discuss different options for interacting with existing header-based code.

The talk will focus above all else on practicality: We will only be covering features that are widely available for use today with the latest compilers and build tools. We will give special attention to the areas where the design practices for modules differ from the familiar header-based approach and address common misconceptions and pitfalls that are typical among developers first encountering the feature. No prior knowledge of modules is required.

CppCon 2023 std::simd: How to Express Inherent Parallelism Efficiently Via ... -- Matthias Kretz

By Blog Staff | Sep 8, 2023 02:41 PM | Tags: None

std::simd: How to Express Inherent Parallelism Efficiently Via Data-parallel Types

Monday, October 2 • 15:15 - 16:15

by Matthias Kretz

Summary of the talk:

C++26 is on route to ship `std::simd`, a facility for expressing data-parallelism via the type system, based on experience from `std::experimental::simd` (Parallelism TS v2). Data-parallel types have the potential to replace many uses of built-in arithmetic types with their `simd` counterpart in compute-intensive workloads, promising factors of speed-ups without algorithmic changes.

This talk presents how data-parallel types are designed to be more than just a thin wrapper around SIMD registers and instructions. They are designed to facilitate generic code, work/integrate with standard algorithms, etc, all while translating into efficient use of parallel execution capabilities. More important, data-parallel types are not "just another way to express data-parallel execution", they also provide new ways to design data structures for efficient memory access (high-throughput without sacrificing locality) using data-structure vectorization. The talk features examples of efficient use of `std::simd`.

Five Advanced Initialization Techniques in C++ -- Bartlomiej Filipek

By Blog Staff | Sep 8, 2023 12:28 PM | Tags: None

From dynamic container operations to compile-time constants, C++ offers a variety of techniques. In this article, we’ll delve into advanced initialization methods likereserve() and emplace_backfor containers to tuples with piecewise_construct and forward_as_tuple. Thanks to those techniques, we can reduce the number of temporary objects and create variables more efficiently.

Five Advanced Initialization Techniques in C++: From reserve() to piecewise_construct and More

By Bartlomiej Filipek

From the article:

As a background, we can use the following class that will be handy to illustrate when its special member functions are called. That way, we’ll be able to see extra temporary objects.

CppCon 2023 Continuous Regression Testing for Safer and Faster Refactoring -- Pejman Ghorbanzade

By Blog Staff | Sep 7, 2023 02:38 PM | Tags: None

Continuous Regression Testing for Safer and Faster Refactoring

Monday, October 2 • 15:15 - 16:15

by Pejman Ghorbanzade

Summary of the talk:

Making code changes to real-world software systems runs the risk of introducing unintended side-effects that are costly to find and fix. To mitigate this risk, engineering teams significantly invest in adopting various software testing practices. Despite best efforts, effectively and reliably identifying software regressions remains a challenge and results in long feedback cycles that hurt developer productivity. This problem is more pronounced in C++ software systems, given that their application domains often impose tight requirements on system safety and performance.

This talk shows you how continuous regression testing can help you find regressions in behavior or performance of your software during the development stage. It is a practical walk-through of how to build a regression testing framework in C++, how to use it to write effective regression tests, and how to integrate it with your CI pipeline to automate the execution of your tests as part of the CI or on a dedicated test server. It also includes recommendations on how to avoid common design pitfalls that lead to tests that are either flaky or untrustworthy or difficult to run at scale.

This talk also introduces a free and open-source software for continuous regression testing C++ applications. We will use a series of hands-on demos to showcase the end-to-end workflow of finding regressions in common C++ development scenarios including refactoring functions, upgrading dependencies, and updating the build toolchain. We also show a few less common use-cases such as profiling the size of binaries and tracking the exported symbols of a shared library, to inspire you to think how regression testing could unlock faster and safer refactoring for you and your team.

CppCon 2023 Abstraction Patterns for Cross Platform Development -- Al-Afiq Yeong

By Blog Staff | Sep 6, 2023 02:35 PM | Tags: None

Abstraction Patterns for Cross Platform Development

Monday, October 2 • 14:00 - 15:00

by Al-Afiq Yeong

Summary of the talk:

Writing code that's intended to work across multiple platforms; be it hardware, graphics APIs, online storefronts or operating systems can be rather difficult. Many software engineers struggle when it comes to abstracting code especially junior engineers be it for a commercial software or a hobby project. To make matters worse, there's often not a lot of materials covering such as advance topic. This presentation aims to discuss several abstraction patterns that can be used to write cross platform code using the features and tools that C++ and operating system offers, from the bad to the good as well as the benefits and pitfalls of each method in terms of complexity, maintainability and performance. A case study of several cross-platform frameworks will also be included in the presentation. Hopefully this presentation will serve as a starting point and become the main reference for engineers across multiple experience levels across various industries when writing cross platform code.

Inside STL: The lists -- Raymond Chen

By Blog Staff | Sep 6, 2023 12:23 PM | Tags: None

Raymond Chen The C++ standard library type list represents a doubly-linked list, and forward_list is a singly-linked list. Fortunately, the implementations of both of these lists are pretty much what you expect.

Inside STL: The lists

By Raymond Chen

From the article:

Let’s start with the simpler forward_list.
template<typename T>
struct forward_list
{
    forward_list_node<T>* head;
};

template<typename T>
struct forward_list_node
{
    forward_list_node<T>* next;
    T value;
};
The forward_list itself is a pointer to the first element of the list, or nullptr if the list is empty. Each subsequent element contains a pointer to the next element, or nullptr if there is no next element.

CppCon 2023 Things Happening in SG14… -- Patrice Roy

By Blog Staff | Sep 5, 2023 02:31 PM | Tags: None

CppCon 2023 Things Happening in SG14…

Monday, October 2 • 14:00 - 15:00

by Patrice Roy

Summary of the talk:

The C++ standards committee is made of a small number of working groups and of a larger number of study groups, including SG14 (low-latency, finances, games and embedded systems). Since pandemic times, SG14 has been brewing a number of proposals meant to make C++ 'better for game developers'. We will look at the principles behind this effort, the output of this work and what this means for C++.

Inside STL: The string -- Raymond Chen

By Blog Staff | Sep 4, 2023 03:07 PM | Tags: None

Raymond Chen You might think that a std::string (and all of its friends in the std::basic_string family) are basically a vector of characters internally. But strings are organized differently due to specific optimizations permitted for strings but not for vectors.

Inside STL: The string

By Raymond Chen

From the article:

The starting point for a std::basic_string is this:¹
template<typename T>
struct basic_string
{
    T* ptr;
    size_t size;
    size_t capacity;
};
The ptr is a pointer to the beginning of the string contents.

The size is the number of characters in the string, not including the null terminator.

The capacity is the string capacity, not including the null terminator.

The picture for this simplified version is as follows: