C++运算符重载实现不同返回类型：结构体下标访问自定义类型

你的核心需求是让ndcpp的[]运算符在访问整行时返回ndcpp类型（而非std::vector<double>），同时保留单个元素的直接访问能力。原代码的问题在于operator[]直接返回了vector<double>&，无法隐式转换为ndcpp，且运行时类型判断无法改变编译期确定的返回类型。

解决方案：使用代理类实现双重行为 #

通过定义一个代理类，让ndcpp::operator[]返回该代理对象：

• 当代理对象被赋值给ndcpp时，隐式转换为包含目标行的ndcpp实例
• 当代理对象使用[]访问元素时，直接返回原数组对应位置的引用

完整代码实现 #

#include <cmath>
#include <stdexcept>
#include <iostream>
#include <vector>

// 用using替代#define，避免文本替换的潜在问题
using MATRIX = std::vector<std::vector<double>>;
using VECTOR = std::vector<double>;

#define print(x) std::cout << x << std::endl;

struct ndcpp;

// 代理类：表示ndcpp的一行，支持转换为ndcpp和元素访问
struct ndcpp_row_proxy {
    VECTOR& row;

    // 隐式转换为ndcpp（将当前行包装为1行的二维数组）
    operator ndcpp() const;

    // 访问行内元素，返回原数据的引用
    double& operator[](int j) {
        if (j < 0 || j >= static_cast<int>(row.size())) {
            throw std::out_of_range("列索引超出范围");
        }
        return row[j];
    }

    // const版本的元素访问
    const double& operator[](int j) const {
        if (j < 0 || j >= static_cast<int>(row.size())) {
            throw std::out_of_range("列索引超出范围");
        }
        return row[j];
    }
};

struct ndcpp{
    MATRIX array;

    // 默认构造函数
    ndcpp() = default;
    // 从MATRIX构造ndcpp
    ndcpp(MATRIX arr) : array(std::move(arr)) {}

    // 重载[]，返回代理对象
    ndcpp_row_proxy operator[](int i) {
        if (i < 0 || i >= static_cast<int>(array.size())) {
            throw std::out_of_range("行索引超出范围");
        }
        return {array[i]};
    }

    // const版本的[]重载
    const ndcpp_row_proxy operator[](int i) const {
        if (i < 0 || i >= static_cast<int>(array.size())) {
            throw std::out_of_range("行索引超出范围");
        }
        return {const_cast<VECTOR&>(array[i])};
    }

    // 获取数组形状（行数，列数）
    std::pair<int, int> shape() const {
        if (array.empty()) {
            return {0, 0};
        }
        return {static_cast<int>(array.size()), static_cast<int>(array[0].size())};
    }
};

// 实现代理类的转换运算符
ndcpp_row_proxy::operator ndcpp() const {
    return ndcpp(MATRIX{row});
}

class numcpp{
public:
    ndcpp make(int m, int n, double default_value = 0){
        if (m < 1 || n < 1){
            throw std::invalid_argument("行数和列数必须大于0");
        }
        return ndcpp(MATRIX(m, VECTOR(n, default_value)));
    }
};

int main() {
    numcpp np;

    ndcpp A = np.make(5, 5);
    ndcpp C = A[0]; // 成功将整行转换为ndcpp

    // 直接修改原数组的元素
    A[0][2] = 3.14;
    print(A[0][2]); // 输出3.14

    // C是原行的拷贝，所以不受原数组修改影响
    print(C[2]); // 输出0
}

关键说明 #

1. 代理类的作用：ndcpp_row_proxy同时实现了operator ndcpp()和operator[]，既满足了将整行转为ndcpp的需求，又保留了直接访问元素的能力。
2. 避免#define的问题：用using定义类型别名比#define更安全，不会出现意外的文本替换。
3. 边界检查：添加了索引越界的异常抛出，提升代码健壮性。
4. 拷贝与视图的选择：当前实现中C是原行的拷贝，如果需要让C成为原数组的视图（修改C会影响原数组），可以调整ndcpp的结构，使其支持引用原数据的视图模式（比如存储原数组指针和行索引）。

内容的提问来源于stack exchange，提问作者kgronk18