C++报错：array must be initialized with a brace-enclosed initializer 求助

首先咱们拆解你遇到的问题，以及代码里的几个关键错误：

直接触发错误的核心原因 #

你写的int dist[V][V] = floydWarshall(graph[][V]);这行有两个致命问题：

• C++里静态数组不能用函数返回值来初始化，静态数组只能用大括号包裹的初始化列表（也就是错误提示里说的"brace-enclosed initializer"）来赋值。
• 你的floydWarshall函数返回类型是int，但你实际想返回的是二维数组，类型完全不匹配；而且C++本身就不允许函数直接返回二维静态数组。

除此之外，原函数还有个隐藏bug：最后return dist[V][V];是数组越界访问，数组下标从0开始，V=4的话最大合法下标是3，访问dist[4][4]会读取内存里的随机值，导致未定义行为。

两种可行的修正方案 #

方案1：通过参数传递修改数组（传统C风格） #

这种方式不需要让函数返回数组，而是直接把要填充的dist数组作为参数传给函数，在函数内部完成修改：

#include <iostream>
using namespace std;
#define V 4
#define INF 999

// 修改函数为void类型，接收graph和dist两个参数
void floydWarshall(int graph[][V], int dist[][V]){
    // 初始化dist为graph的副本
    for (int i = 0; i < V; i++)
        for (int j = 0; j < V; j++)
            dist[i][j] = graph[i][j];
    
    // Floyd-Warshall核心逻辑不变
    for (int k = 0; k < V; k++) {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                // 额外判断：避免两个INF相加导致整数溢出
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j])
                    dist[i][j] = dist[i][k] + dist[k][j];
            }
        }
    }
}

int main() {
    // 示例图初始化
    int graph[V][V] = {
        {0, 5, INF, 10},
        {INF, 0, 3, INF},
        {INF, INF, 0, 1},
        {INF, INF, INF, 0}
    };
    int dist[V][V]; // 声明要填充的dist数组
    floydWarshall(graph, dist); // 调用函数填充dist
    
    // 打印结果
    cout << "最短路径矩阵：" << endl;
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (dist[i][j] == INF)
                cout << "INF ";
            else
                cout << dist[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

方案2：使用std::vector（现代C++风格） #

如果想让函数直接返回结果，推荐用vector替代静态数组，它支持直接拷贝和返回，还能避免静态数组的大小限制问题：

#include <iostream>
#include <vector>
using namespace std;
const int V = 4;
const int INF = 999;

// 函数返回vector<vector<int>>类型
vector<vector<int>> floydWarshall(const vector<vector<int>>& graph){
    vector<vector<int>> dist = graph; // 直接初始化dist为graph的副本
    
    for (int k = 0; k < V; k++) {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                // 同样添加溢出判断
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j])
                    dist[i][j] = dist[i][k] + dist[k][j];
            }
        }
    }
    return dist;
}

int main() {
    // 用vector初始化图
    vector<vector<int>> graph = {
        {0, 5, INF, 10},
        {INF, 0, 3, INF},
        {INF, INF, 0, 1},
        {INF, INF, INF, 0}
    };
    
    // 直接接收函数返回的结果
    vector<vector<int>> dist = floydWarshall(graph);
    
    // 打印结果
    cout << "最短路径矩阵：" << endl;
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (dist[i][j] == INF)
                cout << "INF ";
            else
                cout << dist[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

额外提醒 #

• 调用函数时，不需要写graph[][V]，直接传graph即可，编译器会自动推导数组维度。
• 处理INF的时候一定要加判断，否则两个极大值相加会溢出变成负数，导致错误的路径更新。

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