C++中const vector<long>&与const vector<long>的传参差异及元素拼接问题

First, let’s clear up the parameter difference you’re asking about—this is a core C++ concept that makes a big difference in efficiency and safety:

Key Differences Between the Two Parameter Types #

• Passing by value (const vector<long>): When you use this, the compiler creates a full copy of the input vector every time you call the function. Even though the const keyword stops you from modifying this copied vector, the copy operation still happens. For small vectors, this might not be noticeable, but for large ones (think thousands of elements), it wastes memory (storing two copies of the vector) and time (copying every element).
• Passing by const reference (const vector<long>&): This doesn’t create a copy. Instead, the function gets a reference (an alias) to the original vector. The const ensures your function can’t modify the original vector—so it’s safe to pass even vectors you want to protect from changes. This is almost always the better choice for non-trivial types like vector, as it avoids unnecessary overhead.

Implementing the Comma-Separated String Function #

Since you mentioned you know the general approach, here’s a clean, efficient implementation using the optimal const vector<long>& parameter, with no trailing comma:

#include <vector>
#include <string>
#include <sstream>

std::string vectorToCommaSeparated(const std::vector<long>& vec) {
    std::ostringstream oss;
    bool isFirstElement = true;
    
    for (long num : vec) {
        if (!isFirstElement) {
            oss << ", ";
        }
        oss << num;
        isFirstElement = false;
    }
    
    return oss.str();
}

How this works: #

• We use std::ostringstream to build the string efficiently (better than direct string concatenation, which can trigger multiple memory allocations).
• A boolean flag tracks whether we’re handling the first element. For every element after the first, we add a comma before the number—this guarantees no trailing comma at the end.
• The const vector<long>& parameter ensures we don’t copy the vector, keeping the function fast even for large inputs.

If you prefer a more index-based loop, here’s another version:

std::string vectorToCommaSeparated(const std::vector<long>& vec) {
    std::ostringstream oss;
    
    for (size_t i = 0; i < vec.size(); ++i) {
        if (i != 0) {
            oss << ", ";
        }
        oss << vec[i];
    }
    
    return oss.str();
}

Both versions are efficient, safe, and solve your original problem while using the optimal parameter type.

内容的提问来源于stack exchange，提问作者Brandon O'Neil