如何为动态分配的二维方阵重载C++的<<输出运算符？

你的代码无法通过重载<<运算符打印方阵，核心有两个问题：

1. 模板非类型参数不支持动态大小：你用的模板参数matrixEdge是编译期常量，但方阵边长n是运行时输入的，编译阶段无法确定，因此模板无法适配这种动态场景。
2. 参数类型不匹配：你重载的运算符参数const customizedType* inputMatrix[matrixEdge]等价于const customizedType**（指向指针数组的指针），但你的pMatrix是int*（一维指针），两者类型完全不兼容，编译器找不到对应的重载函数。

下面提供两种可行的解决方案：

方案一：封装为类（推荐，更安全） #

把方阵封装成类，既可以管理内存避免泄漏，也能自然重载<<运算符：

#include <iostream>
#include <stdexcept>
using namespace std;

class IntMatrix {
private:
    int* data;
    int edge;
public:
    // 构造函数：创建指定边长的方阵
    IntMatrix(int n) : edge(n) {
        if (n <= 0 || n > 20) {
            throw invalid_argument("边长必须在1~20之间");
        }
        data = new int[n * n];
    }

    // 析构函数：自动释放内存
    ~IntMatrix() {
        delete[] data;
    }

    // 禁用拷贝构造与赋值（避免浅拷贝问题，可按需实现深拷贝）
    IntMatrix(const IntMatrix&) = delete;
    IntMatrix& operator=(const IntMatrix&) = delete;

    // 重载[]运算符，方便访问元素
    int& operator[](int index) {
        return data[index];
    }

    const int& operator[](int index) const {
        return data[index];
    }

    // 获取方阵边长
    int getEdge() const {
        return edge;
    }
};

// 重载<<运算符，打印IntMatrix对象
ostream& operator<<(ostream& os, const IntMatrix& mat) {
    int edge = mat.getEdge();
    int totalSize = edge * edge;
    os << "{ ";
    for (int i = 0; i < totalSize; ++i) {
        os << mat[i] << ' ';
        // 每打印一行末尾添加闭合括号，换行后开启新行
        if ((i + 1) % edge == 0 && i < totalSize - 1) {
            os << "}" << endl << "{ ";
        }
    }
    os << "}" << endl;
    return os;
}

int main() {
    int n, i = 0;
    int value;

    // 输入合法边长
    do {
        cin >> n;
    } while (n <= 0 || n > 20);

    // 创建方阵对象
    IntMatrix mat(n);

    // 输入方阵元素
    do {
        cin >> value;
        mat[i] = value;
        i++;
    } while (i < n * n);

    // 直接用<<打印方阵
    cout << mat;

    return 0;
}

方案二：使用包装器结构体（兼容原有代码） #

如果不想修改原有的数组创建逻辑，可以用一个包装器结构体把指针和边长打包，再重载这个结构体的<<运算符：

#include <iostream>
using namespace std;

// 模板包装器，适配任意类型的一维模拟方阵
template<typename T>
struct MatrixWrapper {
    const T* data;
    int edge;
    MatrixWrapper(const T* d, int e) : data(d), edge(e) {}
};

// 重载<<运算符，打印包装后的方阵
template<typename T>
ostream& operator<<(ostream& os, const MatrixWrapper<T>& wrap) {
    int totalSize = wrap.edge * wrap.edge;
    os << "{ ";
    for (int i = 0; i < totalSize; ++i) {
        os << wrap.data[i] << ' ';
        if ((i + 1) % wrap.edge == 0 && i < totalSize - 1) {
            os << "}" << endl << "{ ";
        }
    }
    os << "}" << endl;
    return os;
}

int main() {
    int n, i = 0;
    int value;

    do {
        cin >> n;
    } while (n <= 0 || n > 20);

    int* pMatrix = new int[n * n];
    if (!pMatrix) return 1;

    do {
        cin >> value;
        *(pMatrix + i) = value;
        i++;
    } while (i < n * n);

    // 用包装器打包指针和边长，通过<<打印
    cout << MatrixWrapper<int>(pMatrix, n);

    // 手动释放内存
    delete[] pMatrix;
    return 0;
}

内容的提问来源于stack exchange，提问作者Hà Huy Giáp