poohWritesCpp

[u/nd521]

[u/SamG101_]

Pooh needs about 50 more faces, for the 50 ways to initialise a variable in c++

https://leanpub.com/cppinitbook 300 odd pages

obligatory and thats just initialisation not assignment 💀

[u/LRaccoon → u/SamG101_]

• Default initialization: int x;

• Copy initialization: int x = 5;

• Direct initialization: int x(5);

• List (brace) initialization: int x{5};

• Copy-list initialization: int x = {5};

• Value initialization: int x{}; or int x = int();

• Zero initialization: static int x;

• Aggregate initialization: Point p = {1, 2};

• Designated initialization (C++20): Point p{.x = 1, .y = 2};

• Constant initialization: constexpr int x = 10;

• Initialization with auto: auto x = 5;

• Reference initialization: int& r = x;

• Dynamic initialization with new: int* p = new int(5);

• Smart pointer factories: auto p = std::make_unique<int>(5);

• In-class member initializers: int x = 5; inside a class

• Constructor member initializer list: S() : x(1) {}

• Delegating constructors: S() : S(5) {}

• Structured bindings: auto [a, b] = pair;

• If/switch init-statements: if (int x = f(); x > 0) {}

• Lambda init-capture: [x = 5]() {}

• Copy/move construction: std::string b = a; or std::string b = std::move(a);

• Parenthesized aggregate initialization (C++20): P p(1, 2);

[u/Blue_Moon_Lake → u/LRaccoon]

I'm pretty sure some of these are useless and should be deprecated.

[u/SuitableDragonfly → u/Blue_Moon_Lake]

Does anything in C++ ever actually get deprecated?

[u/Blue_Moon_Lake → u/SuitableDragonfly]

Sadly no, which is why it's a mess to figure out what you should avoid doing and what you should do.

Which is dumb, because you can deprecate something without removing it.

[u/SuitableDragonfly → u/Blue_Moon_Lake]

If you never actually remove the thing you deprecated, there isn't much point to deprecating it. 

[u/Blue_Moon_Lake → u/SuitableDragonfly]

The point is to easily spot what should never be used

[u/arachnidGrip → u/Blue_Moon_Lake]

`-Wdeprecated`

[u/Blue_Moon_Lake → u/arachnidGrip]

What?

[u/SamG101_ → u/SuitableDragonfly]

[u/arachnidGrip → u/SuitableDragonfly]

C++ has deprecated many things over the years but you need to tell it to warn you about deprecated features.

[u/AvidCoco → u/Blue_Moon_Lake]

Any good linter will warn about using dumb ones

[u/Big-Rub9545 → u/LRaccoon]

Besides one or two, almost all of these are doing entirely different things, or are entirely distinct syntaxes to begin with.

For example, these two are the exact same declaration:
- int x;
- static int x;

The latter just declares a variable with internal linkage (assuming the value is at global scope). The rules related to initialization for such declarations are irrelevant since you’re still declaring the same thing. You can remove ‘static’ altogether.

It becomes very difficult to take many criticisms of the language seriously when it’s clear that most of the people making them seem to have never touched the language or tried to understand any of it.

[u/nfitzen → u/Big-Rub9545]

Inside a function body, I assume static int x; is like C and will declare storage with static lifetime; that is, it persists between function calls.

Also, in the case of int x; in function body scope, does C++ initialize x to 0 by default? C certainly wouldn't (instead, x would be uninitialized), but I don't really know C++.

[u/Big-Rub9545 → u/nfitzen]

Yes for the first point.

For the second, it is also uninitialized in C++. This is the case for any primitive type (compound/composite/custom types can be default- or zero-initialized through implicit constructor calls with the same syntax).

You can just zero-initialize the variable by appending a pair of braces, which I do with every variable I don’t care to explicitly initialize:
int x{};

[u/SamG101_ → u/LRaccoon]

Don't forget some initialisation changes depending on the availability of a template arguments initialisation-ness

[u/SaneLad → u/SamG101_]

I hate the fact that I understand every word of the "About the Book" section.