C++减少内存拷贝实现零开销转换

std::string_view

std::span

&&

std::vector

std::string

std::string_view

std::span

std::vector

std::vector<int> big_vec = create_large_vector();

void process(std::vector<int> data)

void process(std::vector<int>&& data)

void process(std::vector<int> data)

process(std::move(big_vec))

big_vec

data

std::move

std::vector<int> create_large_vector() {
    std::vector<int> v(1000000);
    // populate v
    return v; // RVO/NRVO might optimize away copy here
}

void process_by_copy(std::vector<int> data) {
    // This will involve a copy if RVO/NRVO doesn't kick in, or if passed by lvalue.
}

void process_by_move(std::vector<int>&& data) {
    // This will move the data.
}

void process_by_value(std::vector<int> data) {
    // This is the "pass by value, then move" idiom.
    // If called with an rvalue, it's a move. If with an lvalue, it's a copy then move.
}

// ... in main or another function
// std::vector<int> my_vec = create_large_vector(); // Potential RVO
// process_by_move(std::move(my_vec)); // Explicit move
// process_by_value(create_large_vector()); // Move construction into parameter
// process_by_value(std::move(my_vec)); // Move construction into parameter

std::string_view

std::span

std::string_view

const char*

size_t

std::span

void log_message(std::string_view msg) {
    // msg does not own the string data, it's just a view
    // No memory allocation or copy for msg itself
    std::cout << "LOG: " << msg << std::endl;
}

// ...
std::string user_input = "This is a long message from user.";
log_message(user_input); // No copy
log_message("Literal string also works."); // No copy

const &

const &

int

double

const &

T&&

std::string_view

std::span

const

T&

// Example API design for a processing pipeline
class DataPacket {
public:
    std::vector<char> payload;
    // ... other data

    // Move constructor
    DataPacket(DataPacket&& other) noexcept : payload(std::move(other.payload)) {
        // ... move other members
    }
    // Move assignment operator
    DataPacket& operator=(DataPacket&& other) noexcept {
        if (this != &other) {
            payload = std::move(other.payload);
            // ... move other members
        }
        return *this;
    }
    // No copy constructor/assignment if we want to enforce move-only
    DataPacket(const DataPacket&) = delete;
    DataPacket& operator=(const DataPacket&) = delete;
};

class Processor {
public:
    // Receives a packet, takes ownership (moves it)
    void process(DataPacket&& packet) {
        // ... process packet.payload
        // packet.payload now holds the data, original object is empty
    }

    // Processes a view of data, doesn't take ownership
    void analyze_payload_segment(std::span<const char> segment) {
        // ... analyze segment data
    }
};

// ... in application code
DataPacket generated_packet; // Filled with data
Processor processor_instance;
processor_instance.process(std::move(generated_packet)); // Move the packet

// If we only need to look at a part of a packet's payload
std::vector<char> raw_data = {'a', 'b', 'c', 'd', 'e'};
processor_instance.analyze_payload_segment(std::span<const char>(raw_data.data() + 1, 3)); // View 'b', 'c', 'd'

std::unique_ptr

std::unique_ptr<T>

T

std::unique_ptr<BigObject> create_big_object() {
    return std::make_unique<BigObject>(); // Returns ownership, no copy
}

void consume_big_object(std::unique_ptr<BigObject> obj) {
    // obj now owns the BigObject
}

// ...
auto my_obj = create_big_object(); // my_obj takes ownership
consume_big_object(std::move(my_obj)); // ownership transferred to consume_big_object
// my_obj is now null