Diving Deep into the C++ Object

In this chapter, we will pay special attention to the object in the C++ language. But what makes the object in C++ so special that we should pay so much attention to it? Well, considering the fact that C++ supports the object-oriented programming paradigm, it is assumed that the object itself takes a central position in the structure of the language. You will see that there are many specifics around objects in C++.

In this chapter, we will delve into the fundamental aspects of objects in C++. We will start by examining how the C++ standard specifies the definition of an object. Moving on from there, we will take a closer look at the different types of object initializations, such as aggregate, direct, and copy initialization, and their use cases.

We will also explore the concept of storage duration for objects. Additionally, we will take a look at the scope and lifetime of objects in C++. We will also see what references are and how they correlate...

Technical requirements

All examples in this chapter have been tested in an environment with the following configuration:

• Linux Mint 21 Cinnamon edition
• GCC 12.2 with compiler flags – -std=c++20
• A stable internet connection
• Please make sure your environment uses these versions or later. For all the examples you can alternatively use https://godbolt.org/.
• All code examples in this chapter are available for download from https://github.com/PacktPublishing/C-Programming-for-Linux-Systems/tree/main/Chapter%204.

Understanding the C++ object model

C++ programs involve the creation, manipulation, and destruction of various entities known as objects. An object in C++ possesses several attributes such as type, size, storage duration, lifetime, alignment requirements, and value. The name of the object is optional.

The lifetime of the named object is bounded by its storage duration, and if the object doesn’t have a name, it is considered a temporary object. However, not all entities in C++ are considered objects. For example, the reference is one such non-object.

First, let’s take a brief look at the terminology because it is important to be aware of it, as it will help us in our daily work with the C++ language.

Declaration versus definition

In C++, the terms declaration and definition are often used to refer to different aspects of a variable, function, or class. Here’s what each term means:

• Declaration: A declaration introduces a name into a program and...

Functors and lambdas

This section will delve into functional objects – their definition, usefulness, and proper usage. We’ll begin by examining an example of a functional object used with an STL algorithm and discuss potential issues, such as the creation of temporary objects and dangling references. After that, we’ll move on to exploring lambda expressions – what they are, how to use them, and specific situations where they can be especially advantageous.

Exploring functional objects

In the Scope, storage duration, and lifetimes section, we looked at various types of object initialization in C++, but our focus was mostly on objects that represent data, such as integers or coordinates. In this section, we’ll shift our attention to another type of object – those designed to be callable, such as a function, but with a crucial difference: they can maintain a state between different function calls. These objects are known as functional objects...

Summary

In this chapter, we explored various aspects of objects in C++, including storage duration, scope, and lifetimes. We distinguished between objects and references and discussed different ways of initializing objects and when these initializations occur. Additionally, we delved into the world of functors, gaining an understanding of what they are and how to use them effectively. Building on that knowledge, we also learned about lambda expressions and their advantages over functors. We covered how to properly use both lambdas and functors with STL algorithms. Armed with this knowledge of object specifics, we can now move on to discussing error handling in C++ in the next chapter.