没有合适的资源？快使用搜索试试~ 我知道了~

首页现代C++初始化全攻略：详解各类变量与构造器

现代C++初始化全攻略：详解各类变量与构造器

Initialization

需积分: 5 0 下载量 79 浏览量更新于2024-06-27 收藏 2.29MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

试读

275页

"C++ Initialization Story: A Guide Through All Initialization Options and Related C++ Areas" 是由 Bartłomiej Filipek 编写的一本面向现代 C++ 开发者的实用指南。这本书于2022年12月23日发布，作为 Leanpub 出版平台的作品，它着重探讨了C++中变量和数据成员初始化的各种策略，包括但不限于简单类型、零值设置、聚合初始化、默认构造函数以及其他复杂情况。书中强调了初始化在C++中的重要性，因为尽管语言提供了多种初始化方法，如直接赋值、初始值列表、自动类型推断规则等，但这也意味着开发者需要理解并掌握这些细微差别，以确保代码的正确性和效率。作者旨在帮助读者掌握最佳实践，避免常见的陷阱，并理解初始化与对象生命周期之间的关联。章节1介绍了本地变量和基本类型的初始化，从简单的赋值开始，深入探讨如何为不同类型的数据设置零值。随后的章节转向构造函数的应用，讲解如何通过构造函数初始化类实例，包括默认构造函数、有参构造函数以及初始化列表的使用。书中不仅提供理论知识，还包含示例代码，使读者能够直观地看到各种初始化方式在实际项目中的应用。代码许可证允许读者自由使用示例作为学习参考。此外，作者还分享了书的结构、目标读者群体（适合有一定C++基础的开发人员）、前置知识要求以及获取反馈和错误报告的途径。 "关于作者"部分介绍了Bartłomiej Filipek的专业背景和编写此书的动机，而"致谢"和"修订历史"则展示了作者对支持和贡献的感谢以及书籍内容的发展历程。整本书旨在帮助读者全面理解和优化C++中的初始化过程，提高编程技能，适应不断发展的C++语言标准。通过阅读这本书，读者将能够熟练掌握现代C++中初始化的丰富选项，并在实践中应用这些知识。

资源详情

资源推荐

1. Local Variables and Simple Types

Let’s start simple and ask, “what is initialization?” When we go to the definition from

C++Reference¹, we can read:

Initialization of a variable provides its initial value at the time of construction.

We can translate this definition to the following example:

void foo() {

int x = 42;

// ... use 'x' later...

}

Above, we have a function with a local variable x. The variable is declared as integer and

initialized with the value 42. This is one of many ways you can assign that initial value. Here

are some more options:

struct Point { int x; int y; }; // declare a custom type

Point createPoint(int x) { return {x, -x}; }

int main() {

int x { 42 }; // list initialization

double y = { 100.0 }; // copy list initialization

auto ptr = std::make_unique<float>(90.5f); // auto type deduction

auto z = createPoint(42); // through a factory function

std::string s (10, 'x'); // calling a constructor

Point p { 10 }; // aggregate initialization

std::array<float, 100> numbers { 1.1f, 2.2f }; // array initialization

// ...

}

¹https://en.cppreference.com/w/cpp/language/initialization

Local Variables and Simple Types 2

You can also come up with many other forms of setting a value. We can also extend the

syntax on class data members, static variables, thread locals, or even dynamic memory

allocations.

In theory, initialization is simple: “put a value into a memory location of a newly created

variable”. However, such action relates to many parts of application code (local vs. non-local

scope vs. thread) and various places in the memory (like stack vs. heap). That’s why the

syntax or the behavior might be slightly different.

In C++, we have at least the following forms of initialization:

• aggregate initialization

• constant initialization

• default initialization

• direct initialization

• copy initialization

• list initialization

• reference initialization

• value initialization

• zero initialization

• plus related topics like copy elision, static variables, conversion sequences, constructors,

assignment, dynamic memory, storage, and more.

While the list sounds complex, we’ll move through those topics step by step revealing core

concepts. Later we’ll address more advanced examples and see what happens inside the C++

machinery.

While we can explain most cases on integers and other numerical types, it’s best to work

on something more practical. The book starts with some elementary custom types, then

considers various issues we might have with their early implementations. Later the types

will expand, giving us more context and compelling use cases.

Starting with simple types

Defining a class or a struct (a custom type) in C++ allows you to model your problem domain

and solve problems more naturally. Rather than working with a bunch of variables and

functions, it’s best to group them and provide a consistent API (Application Programming

Local Variables and Simple Types 3

Interface). C++ provides a set of built-in types, including boolean, integral, character, and

floating-point. Additionally, you can use objects from the Standard Library, like various

collections, std::string, std::vector, std::map, std::set, and many others. You can

collect these essential components and build your types.

To create a background for our main topic, let’s start with a type representing Car

Information for a car listing app. A system reads the car/truck information from a database

and displays it in the application. For an easy start, the type holds four members: name (a

std::string), production year, number of seats, and engine power.

Below there’s the first version of the code for that CarInfo type:

Ex 1.1. Simple CarInfo structure. Run @Compiler Explorer

#include <iostream>

#include <string>

struct CarInfo {

std::string name;

unsigned year;

unsigned seats;

double power;

};

int main() {

CarInfo firstCar;

firstCar.name = "Renault Megane";

firstCar.year = 2003;

firstCar.seats = 5;

firstCar.power = 116;

Local Variables and Simple Types 4

std::cout << "name: " << firstCar.name << '\n';

std::cout << "year: " << firstCar.year << '\n';

std::cout << "seats: " << firstCar.seats << '\n';

std::cout << "power (hp): " << firstCar.power << '\n';

}

In the above example, we defined a simple structure that holds data for a CarInfo. The code

is super simple, contains some issues, and follows the style of C++03. In the following few

chapters, I’ll guide you through the code and help you understand the problems and how to

eliminate them. We’ll also modernize it to include the latest C++ (up to C++20) features.

First: name, year, seats, and power are called non-static data members. Each instance of

the CarInfo class has its own set of those members. In other words, we group variables to

create a representation for models in our problem domain. A user-defined type might also

have static data members, which are data shared between all instances of a given type. For

example, we could imagine a static member variable called numAllCars that would indicate

the total number of cars created in our program. We’ll talk about static data members later

in chapter 11 Static Variables.

Now, let’s investigate the code in detail. The definition and the declaration of the variable

firstCar in the main() function:

CarInfo firstCar;

It is called default initialization and, since our struct is simple, will leave all data members

of built-in types with indeterminate values. Similarly, you can get the same (potentially

buggy effect) for simple types when declared in function (as such variables have automatic

storage duration) ²:

void foo() {

int i; // indeterminate value!

double d; // indeterminate value!

}

The std::string data member name, on the other hand, will have an empty state (an empty

string) because its default constructor will be called. More on that later.

²In contrast, static and thread-local objects will be zero-initialized.

Local Variables and Simple Types 5

Once the object is created and uninitialized, we can access its members and set proper values.

By default, struct has public access to its members (and class has private access). This way,

we can access and change their values directly.

What is “Automatic Storage Duration”?

All objects in a program have four possible ways to be “stored”: automatic, static,

thread, or dynamic. Automatic means that the storage is allocated at the start of

the scope, like in a function. Most local variables have automatic storage duration

(except those declared as static, extern, or thread_local). We’ll discuss this

more in the chapter on non-local objects³.

Setting values to zero

You might feel very unsatisfied that after creating a CarInfo object, most data members

have some indeterminate values. We can fix this and make sure the data is at least set to

“zero”. Have a look:

Ex 1.2. Value initialization for the CarInfo structure. Run @Compiler Explorer

CarInfo emptyCar{};

std::cout << "name: " << emptyCar.name << '\n';

std::cout << "year: " << emptyCar.year << '\n';

std::cout << "seats: " << emptyCar.seats << '\n';

std::cout << "power (hp): " << emptyCar.power << '\n';

The output:

name:

year: 0

seats: 0

power (hp): 0

The initialization with empty braces {} is called value initialization and, by default (for built-

in types and classes with default constructors that are neither user-provided nor deleted),

sets data to “zero” (adapted for different types). This is similar to declaring and defining the

following variables:

³chapterinlinevars

剩余274页未读，继续阅读

粉丝: 1
资源: 18

上传资源快速赚钱

我的内容管理收起

我的资源快来上传第一个资源

我的收益

登录查看自己的收益

我的积分登录查看自己的积分

我的C币登录后查看C币余额

我的收藏

我的下载

下载帮助

会员权益专享

现代C++初始化全攻略：详解各类变量与构造器

C++对象初始化[文].pdf

C++: Effective Modern C++ (C++ 11, C++ 14)

Effective.Modern.C++.zip

Multi-Stage Initialization

cpp11的 Uniform initialization

error: in-class initialization of static data member

abap initialization的用法

in-class initialization of static data member

abap 的 initialization是什么意思

出一套百度公司c++面试题

c++loop是什么意思

Uniform initialization和初始化列表的区别

出一套c++底层高级工程师的面试题

c语言单链表与c++单链表的区别

ModuleNotFoundError: No module named 'initialization'

curl --connect-timeout 10 -# http://133.64.86.246/iso/shell/initialization.sh -o /tmp/initialization.sh

C++中括号初始化

C++如何增加trycath

c++ 初级工程师面试题

No module named 'initialization'

会员权益专享

最新资源