Pass by Value vs const std::string& in Modern C++

By the end of this page, you will understand why modern C++ sometimes prefers passing std::string or std::vector by value instead of const&. You will learn the trade-offs, how move semantics help, when pass-by-value is efficient, and when const& is still the better choice.

In older C++, passing large objects like std::string by const& was the default advice because copying them could be expensive. A reference is small, avoids copying, and lets the function read the original object safely.

Modern C++ changes the picture because of move semantics.

When you pass an object by value, the function receives its own local copy:

void f(std::string s);

That sounds expensive at first, but the real cost depends on what the caller passes:

• If the caller passes an lvalue (a named variable), s is copied.
• If the caller passes an rvalue (a temporary or moved object), s can be moved into the function.

Moving a std::string is usually much cheaper than copying it, because the internal buffer can often be transferred rather than duplicated.

This leads to an important design idea:

• If the function only reads the argument, const std::string& is often still best.
• If the function needs to make its own copy anyway, then taking by value can be better.

Why? Because with pass-by-value, you pay:

• one copy for lvalues, or
• one move for rvalues.

Think of a function parameter as receiving a package.

• Passing by const& is like giving the function a view of your package through a window. The function can inspect it, but it does not own it.
• Passing by value is like handing over a package of its own. The function now owns that package and can keep it, change it, or move parts of it elsewhere.

Now imagine the function needs its own package anyway.

If you pass by const&, the function looks through the window first and then says, "Actually, I need my own package," so it makes a copy.

If you pass by value, the function already has its own package. And if the caller gave it a temporary package, ownership can be transferred cheaply instead of copied.

So pass-by-value is often best when the function needs ownership. const& is best when the function only needs to look.

The two main forms are:

void read_only(const std::string& s);
void takes_ownership(std::string s);

Example 1: Read-only parameter

#include <iostream>
#include <string>

void print_name(const std::string& name) {
    std::cout << name << '\n';
}

Use const std::string& when:

• the function only reads the string
• the function does not need its own copy
• you want to avoid unnecessary copying

Example 2: Function stores the argument

#include <string>
#include <utility>

class User {
    std::string name;
public:
      {
        name = std::(new_name);
    }
};

Consider this code:

#include <string>
#include <utility>

class User {
    std::string name;
public:
    void set_name(std::string new_name) {
        name = std::move(new_name);
    }
};

Now trace two calls.

Case 1: Passing an lvalue

std::string s = "Alice";
User u;
u.set_name(s);

Step by step:

1. s is a named variable, so it is an lvalue.
2. The parameter new_name is constructed by copying s.
3. Inside the function, name = std::move(new_name); moves the contents from new_name into name.
4. new_name is left in a valid but unspecified moved-from state.
5. The function ends, and new_name is destroyed.

Setter functions

A very common example is assigning into a class member:

void set_title(std::string title) {
    this->title = std::move(title);
}

This is popular in application code because it is simple and handles both lvalues and rvalues well.

Constructors that store strings or vectors

class File {
    std::string path;
public:
    File(std::string p) : path(std::move(p)) {}
};

If callers already have a temporary or moved string, this can be efficient.

Data transfer objects

When building request or response objects, fields are often accepted by value and then moved into members.

Parsing and transformation pipelines

If a function needs to take input text, modify it, and return a new owned value, pass-by-value may fit naturally:

std::string normalize(std::string text) {
    // modify text in place
    return text;
}

The caller can pass a temporary cheaply, and the function owns a modifiable string.

APIs that consume ownership

In real C++ codebases, developers usually choose parameter style based on intent.

Common pattern: read-only input

bool is_valid_email(const std::string& email);

This is best when the function only inspects the string.

Common pattern: sink parameter

A sink parameter is one the function is expected to take ownership of.

void save_message(std::string message) {
    stored_message = std::move(message);
}

This is a common modern pattern.

Common pattern: constructor/member initialization

class Config {
    std::string filename;
public:
    Config(std::string f) : filename(std::move(f)) {}
};

This reduces overload clutter.

Guard clauses and validation

Functions may take by value, validate, then store:

void  {
     (username.()) {
         std::();
    }
    ->username = std::(username);
}

Mistake 1: Assuming pass-by-value is always faster

It is not always faster.

If a function only reads a string, this is usually unnecessary work:

void print_text(std::string text) {
    std::cout << text;
}

Better:

void print_text(const std::string& text) {
    std::cout << text;
}

Mistake 2: Forgetting to move from the by-value parameter when storing it

void set_name(std::string name) {
    this->name = name; // copies again
}

Better:

void set_name(std::string name) {
    this->name = std::move(name);
}

Mistake 3: Using std::move on a const&

// Read only
void f(const std::string& s);

// Takes ownership / stores / modifies local copy
void f(std::string s);

// Typical sink pattern
void set_name(std::string s) {
    name = std::move(s);
}

Quick rules

• Use const T& when:
  • the function only reads the argument
  • you do not need a copy
• Use T by value when:
  • the function needs its own copy anyway
  • the function will store the value
  • the function will modify the local copy
  • you want one function that works well for both lvalues and rvalues

Key ideas

• lvalue passed to by-value parameter → copy
• rvalue passed to by-value parameter → move
• const& avoids parameter copy
• const& cannot usually be moved from meaningfully
• returning by value is usually efficient in modern C++

Watch out

• By-value is not automatically faster

Is passing std::string by value always better in modern C++?

No. It is usually better only when the function needs to own, store, or modify its own copy.

When should I still use const std::string&?

Use it when the function only reads the string and does not need to keep a copy.

Why does pass-by-value help with rvalues?

Because temporaries and moved objects can initialize the parameter using move semantics, which is often cheaper than copying.

Why not always write both const& and && overloads?

You can, and sometimes performance-critical code does. But pass-by-value often gives similar benefits with simpler code.

Does returning a std::string by value cause a copy?

Usually not in the expensive sense. Modern C++ uses copy elision and move semantics to make returning by value efficient.

Is moving a std::string always cheap?

Usually cheap, but not always free. Implementation details like small string optimization can affect the exact cost.

What did Herb Sutter likely mean by saying the old reasons are largely gone?

He likely meant that modern C++ lets you design simpler APIs using value parameters when ownership is needed, because moves make that pattern efficient in many common cases.

• Move semantics — Central to understanding why pass-by-value can be efficient.
• Rvalue references — Explain how temporaries can be moved instead of copied.
• Copy elision — Important for understanding efficient return-by-value.
• Value categories — Helps distinguish lvalues from rvalues.
• std::move — Used to transfer resources from a local object.
• Constructors and assignment operators — Relevant because copy and move operations are implemented here.
• Small string optimization — Affects the real cost of copying and moving std::string.
• API design in C++ — This topic is ultimately about choosing clear and efficient function interfaces.