Tweaks

Chapter 1: Consider Pass by Value

The title of Item 41 is very precise: "Consider pass by value for copyable parameters that are cheap to move and always copied." Every word matters.

c++
Widget w;
std::string name("Bart");

w.addName(name);             // lvalue: copy-construct param + move into vector
w.addName(name + "Jenne");    // rvalue: move-construct param + move into vector

Four conditions for pass by value

Chapter 2: Cost Analysis

Let's count copy and move operations for each approach when adding a name to a Widget.

Chapter 3: Caveats

Pass by value has hidden costs that the simple "one extra move" analysis misses.

Construction vs assignment

c++
class Password {
    std::string text;
public:
    void changeTo(std::string newPwd)      // pass by value
    { text = std::move(newPwd); }         // assignment, not construction
};

std::string initPwd("Supercalifragilisticexpialidocious");
Password p(initPwd);

std::string newPwd("Beware the Jabberwock");
p.changeTo(newPwd);  // copies newPwd, then move-assigns to text
// But text already had enough capacity! With by-ref, no allocation needed.

Function call chains

c++
// Each function takes by value: "only one extra move"
void addName(std::string name) {
    validateName(name);  // another by-value copy!
    ...
}
void validateName(std::string name) {
    logName(name);       // yet another!
    ...
}
// "One extra move" per function * N functions = N extra moves
// By-reference chains incur zero accumulated overhead

Slicing

c++
class Widget { ... };
class SpecialWidget : public Widget { ... };

void process(Widget w);  // pass by value: SLICES derived types!
SpecialWidget sw;
process(sw);            // sw's SpecialWidget-ness is lost

The complete picture: when to use what

Chapter 4: Emplacement vs Insertion

When you add a string literal to a vector<string> via push_back, a temporary std::string is created. emplace_back can avoid that entirely.

c++
std::vector<std::string> vs;

vs.push_back("xyzzy");   // creates temp string, then moves it in
vs.emplace_back("xyzzy"); // constructs string DIRECTLY in the vector

What push_back actually does

What emplace_back does

Every container has emplacement counterparts: emplace_back, emplace_front, emplace, emplace_hint, emplace_after.

c++
// emplace_back forwards any arguments to the string constructor
vs.emplace_back(50, 'x');  // constructs string(50, 'x') directly in-place

Chapter 5: When to Emplace

In theory, emplacement is never slower than insertion. In practice, it depends. Here's a heuristic for when emplacement is most likely to win:

Container types and construction vs assignment

Danger: explicit constructors

c++
std::vector<std::regex> regexes;

regexes.push_back(nullptr);    // ERROR: won't compile (implicit conversion rejected)
regexes.emplace_back(nullptr); // COMPILES! Direct init uses explicit ctor. UB at runtime.

// Because:
std::regex r1 = nullptr;  // copy init: explicit ctor blocked → error
std::regex r2(nullptr);   // direct init: explicit ctor allowed → compiles (UB)

Copy init vs direct init: the rule

Danger: exception safety with new

c++
std::list<std::shared_ptr<Widget>> ptrs;

// push_back: safe. Temporary shared_ptr created BEFORE push_back.
// If allocation fails, shared_ptr destructor cleans up.
ptrs.push_back(std::shared_ptr<Widget>(new Widget, killWidget));

// emplace_back: UNSAFE. Raw pointer forwarded into container.
// If node allocation throws, raw pointer is leaked!
ptrs.emplace_back(new Widget, killWidget);

// Fix: create the shared_ptr first, then emplace the rvalue
auto spw = std::shared_ptr<Widget>(new Widget, killWidget);
ptrs.emplace_back(std::move(spw));

Chapter 6: Cost Visualized

See how the three parameter-passing approaches compare, and how emplacement vs insertion differs.

The emplace_back decision flowchart

When emplacement does NOT help

c++
std::vector<std::string> vs;
std::string queen("Donna Summer");

// Same type passed — no temporary either way
vs.push_back(queen);     // copy-construct into vector
vs.emplace_back(queen);  // also copy-construct. No difference.

// Emplacement at occupied position — may need temporary for move-assign
vs.emplace(vs.begin(), "xyzzy");  // move-assigns, may create temp

Chapter 7: Beyond

Emplacement function reference

* push_front/emplace_front not available for vector and string.

Key principles from Effective Modern C++

The Complete Item Index

"The most important part of each Item is not the advice it offers, but the rationale behind the advice." — Scott Meyers