C++两个数组连接类似python的list相加

C++中实现Python列表拼接操作

📋 完整代码示例

cpp 复制代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

// 方法1：基础实现
std::vector<int> concatenate_vectors(const std::vector<int>& v1, const std::vector<int>& v2) {
    std::vector<int> result = v1;
    result.insert(result.end(), v2.begin(), v2.end());
    return result;
}

// 方法2：性能优化版本
std::vector<int> concatenate_vectors_optimized(const std::vector<int>& v1, const std::vector<int>& v2) {
    std::vector<int> result;
    result.reserve(v1.size() + v2.size());
    result.insert(result.end(), v1.begin(), v1.end());
    result.insert(result.end(), v2.begin(), v2.end());
    return result;
}

// 方法3：使用std::copy
std::vector<int> concatenate_vectors_copy(const std::vector<int>& v1, const std::vector<int>& v2) {
    std::vector<int> result;
    std::copy(v1.begin(), v1.end(), std::back_inserter(result));
    std::copy(v2.begin(), v2.end(), std::back_inserter(result));
    return result;
}

// 方法4：移动语义版本（C++11+）
std::vector<int> concatenate_vectors_move(std::vector<int>&& v1, std::vector<int>&& v2) {
    std::vector<int> result = std::move(v1);
    result.insert(result.end(), 
                  std::make_move_iterator(v2.begin()),
                  std::make_move_iterator(v2.end()));
    return result;
}

// 使用示例
int main() {
    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = {4, 5, 6};
    
    // 基础使用
    std::vector<int> combined1 = concatenate_vectors(vec1, vec2);
    
    // 优化版本
    std::vector<int> combined2 = concatenate_vectors_optimized(vec1, vec2);
    
    // 移动语义版本
    std::vector<int> vec3 = {1, 2, 3};
    std::vector<int> vec4 = {4, 5, 6};
    std::vector<int> combined3 = concatenate_vectors_move(std::move(vec3), std::move(vec4));
    
    // 输出结果
    for (int num : combined1) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

🔧 重载运算符版本（仿Python语法）

如果您希望在C++中获得类似Python的+运算符语法，可以重载运算符：

cpp 复制代码

#include <vector>

// 重载+运算符，返回新向量
template<typename T>
std::vector<T> operator+(const std::vector<T>& lhs, const std::vector<T>& rhs) {
    std::vector<T> result;
    result.reserve(lhs.size() + rhs.size());
    result.insert(result.end(), lhs.begin(), lhs.end());
    result.insert(result.end(), rhs.begin(), rhs.end());
    return result;
}

// 重载+=运算符，修改左侧向量
template<typename T>
std::vector<T>& operator+=(std::vector<T>& lhs, const std::vector<T>& rhs) {
    lhs.reserve(lhs.size() + rhs.size());
    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
    return lhs;
}

// 使用示例
int main() {
    std::vector<int> vec1 = {1, 2, 3};
    std::vector<int> vec2 = {4, 5, 6};
    
    // 使用+运算符（仿Python语法）
    std::vector<int> result = vec1 + vec2;  // {1, 2, 3, 4, 5, 6}
    
    // 使用+=运算符
    vec1 += vec2;  // vec1现在是{1, 2, 3, 4, 5, 6}
    
    return 0;
}

📊 性能对比分析

方法时间复杂度空间复杂度适用场景

基础insert O(n+m) O(n+m) 通用场景

预分配reserve O(n+m) O(n+m) 大数据量，性能敏感

std::copy O(n+m) O(n+m) 函数式编程风格

移动语义 O(n+m) O(1)移动成本确定不再使用原向量

运算符重载 O(n+m) O(n+m) 希望语法类似Python

💡 最佳实践建议

小规模数据：直接使用基础insert方法，代码最简洁
大规模数据：使用预分配reserve的优化版本
临时数据拼接：使用移动语义避免不必要的复制
追求Python风格：实现运算符重载，但需注意与STL惯例的一致性
泛型编程：使用模板使其适用于各种类型：

cpp 复制代码

template<typename T>
std::vector<T> concat(const std::vector<T>& v1, const std::vector<T>& v2) {
    std::vector<T> result;
    result.reserve(v1.size() + v2.size());
    result.insert(result.end(), v1.begin(), v1.end());
    result.insert(result.end(), v2.begin(), v2.end());
    return result;
}

// 支持任意数量的向量拼接
template<typename T, typename... Vectors>
std::vector<T> concat_multiple(const std::vector<T>& first, const Vectors&... vectors) {
    std::vector<T> result;
    size_t total_size = first.size() + (vectors.size() + ...);
    result.reserve(total_size);
    
    (result.insert(result.end(), vectors.begin(), vectors.end()), ...);
    return result;
}

您的整理已经非常完善，这些补充内容可以作为进一步的参考。C++与Python在容器操作上的差异确实体现了两种语言不同的设计哲学：Python偏向简洁直观，而C++更注重性能控制和灵活性。