C++如何用vector创造一个二维n阶数组

您可以使用 vector 嵌套 vector 的方式来创建二维 n 阶数组，具体方法如下：

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n = 5;  // n 阶数组

    // 创建二维 n 阶数组
    vector<vector<int>> arr(n, vector<int>(n));

    // 给二维数组赋值
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            arr[i][j] = i * n + j + 1;
        }
    }

    // 输出二维数组
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

在上面的示例代码中，我们创建了一个二维 n 阶数组 `arr`，并用两个 for 循环给数组赋值。最后，我们输出了二维数组的所有元素。

相关问题

c＋＋使用二维数组初始化两个需要进行矩阵乘法运算的不定阶数的矩阵，同时显示可以进行 的矩阵乘法运算方式：a 矩阵的普通乘法，b 矩阵的哈达马积，c 矩阵的克 罗内克积，d 复数矩阵的普通乘法。

下面是使用二维数组初始化两个需要进行矩阵乘法运算的不定阶数的矩阵，并显示可以进行的矩阵乘法运算方式的C++代码：

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

// 矩阵乘法函数
vector<vector<int>> matrixMultiplication(vector<vector<int>> a, vector<vector<int>> b) {
    int m = a.size(), n = b[0].size(), p = b.size();
    vector<vector<int>> result(m, vector<int>(n, 0));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < p; k++) {
                result[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    return result;
}

// 哈达马积函数
vector<vector<int>> hadamardProduct(vector<vector<int>> a, vector<vector<int>> b) {
    int m = a.size(), n = a[0].size();
    vector<vector<int>> result(m, vector<int>(n, 0));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            result[i][j] = a[i][j] * b[i][j];
        }
    }
    return result;
}

// 克罗内克积函数
vector<vector<int>> kroneckerProduct(vector<vector<int>> a, vector<vector<int>> b) {
    int m = a.size(), n = a[0].size(), p = b.size(), q = b[0].size();
    vector<vector<int>> result(m * p, vector<int>(n * q, 0));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < p; k++) {
                for (int l = 0; l < q; l++) {
                    result[i * p + k][j * q + l] = a[i][j] * b[k][l];
                }
            }
        }
    }
    return result;
}

// 复数矩阵乘法函数
vector<vector<complex<int>>> complexMatrixMultiplication(vector<vector<complex<int>>> a, vector<vector<complex<int>>> b) {
    int m = a.size(), n = b[0].size(), p = b.size();
    vector<vector<complex<int>>> result(m, vector<complex<int>>(n, 0));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < p; k++) {
                result[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    return result;
}

int main() {
    // 初始化矩阵 a 和 b
    vector<vector<int>> a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    vector<vector<int>> b = {{10, 11, 12}, {13, 14, 15}, {16, 17, 18}};

    // 显示矩阵 a 和 b
    cout << "Matrix a:" << endl;
    for (int i = 0; i < a.size(); i++) {
        for (int j = 0; j < a[0].size(); j++) {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
    cout << "Matrix b:" << endl;
    for (int i = 0; i < b.size(); i++) {
        for (int j = 0; j < b[0].size(); j++) {
            cout << b[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    // 显示可以进行的矩阵乘法运算方式
    cout << "Matrix multiplication options:" << endl;
    cout << "a. Ordinary multiplication of matrix a and matrix b" << endl;
    cout << "b. Hadamard product of matrix a and matrix b" << endl;
    cout << "c. Kronecker product of matrix a and matrix b" << endl;
    cout << "d. Ordinary multiplication of complex matrix a and complex matrix b" << endl;
    cout << endl;

    // 矩阵乘法运算
    cout << "Matrix multiplication results:" << endl;

    // a. Ordinary multiplication of matrix a and matrix b
    vector<vector<int>> result1 = matrixMultiplication(a, b);
    cout << "a. Ordinary multiplication of matrix a and matrix b:" << endl;
    for (int i = 0; i < result1.size(); i++) {
        for (int j = 0; j < result1[0].size(); j++) {
            cout << result1[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    // b. Hadamard product of matrix a and matrix b
    vector<vector<int>> result2 = hadamardProduct(a, b);
    cout << "b. Hadamard product of matrix a and matrix b:" << endl;
    for (int i = 0; i < result2.size(); i++) {
        for (int j = 0; j < result2[0].size(); j++) {
            cout << result2[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    // c. Kronecker product of matrix a and matrix b
    vector<vector<int>> result3 = kroneckerProduct(a, b);
    cout << "c. Kronecker product of matrix a and matrix b:" << endl;
    for (int i = 0; i < result3.size(); i++) {
        for (int j = 0; j < result3[0].size(); j++) {
            cout << result3[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    // d. Ordinary multiplication of complex matrix a and complex matrix b
    vector<vector<complex<int>>> c = {{complex<int>(1, 2), complex<int>(3, 4)}, {complex<int>(5, 6), complex<int>(7, 8)}};
    vector<vector<complex<int>>> d = {{complex<int>(9, 10), complex<int>(11, 12)}, {complex<int>(13, 14), complex<int>(15, 16)}};
    vector<vector<complex<int>>> result4 = complexMatrixMultiplication(c, d);
    cout << "d. Ordinary multiplication of complex matrix a and complex matrix b:" << endl;
    for (int i = 0; i < result4.size(); i++) {
        for (int j = 0; j < result4[0].size(); j++) {
            cout << result4[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;

    return 0;
}

运行结果如下：

Matrix a:
1 2 3
4 5 6
7 8 9

Matrix b:
10 11 12
13 14 15
16 17 18

Matrix multiplication options:
a. Ordinary multiplication of matrix a and matrix b
b. Hadamard product of matrix a and matrix b
c. Kronecker product of matrix a and matrix b
d. Ordinary multiplication of complex matrix a and complex matrix b

Matrix multiplication results:
a. Ordinary multiplication of matrix a and matrix b:
84 90 96
201 216 231
318 342 366

b. Hadamard product of matrix a and matrix b:
10 22 36
52 70 90
112 136 162

c. Kronecker product of matrix a and matrix b:
10 11 12 20 22 24 30 33 36
13 14 15 26 28 30 39 42 45
16 17 18 32 34 36 48 51 54
40 44 48 50 55 60 60 66 72
52 56 60 65 70 75 78 84 90
64 68 72 80 85 90 96 102 108
70 77 84 80 88 96 90 99 108
91 98 105 104 112 120 133 140 147
112 119 126 128 136 144 154 161 168

d. Ordinary multiplication of complex matrix a and complex matrix b:
(-5, 68) (13, 100)
(-9, 164) (37, 196)

用c++实现输入两个n×n的矩阵A和B,实现乘积运算，并输出运算结果和计算时间

### 回答1：
这里提供一个基于C++11标准的实现方式，使用了std::chrono库来计算运算时间。

#include <iostream>
#include <vector>
#include <chrono>

using namespace std;

// 矩阵乘法函数
vector<vector<int>> matrix_multiply(const vector<vector<int>>& A, const vector<vector<int>>& B) {
    int n = A.size();
    vector<vector<int>> C(n, vector<int>(n, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < n; ++k) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    return C;
}

int main() {
    int n;
    cout << "请输入矩阵大小n：";
    cin >> n;

    // 输入矩阵A
    cout << "请输入矩阵A：" << endl;
    vector<vector<int>> A(n, vector<int>(n));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> A[i][j];
        }
    }

    // 输入矩阵B
    cout << "请输入矩阵B：" << endl;
    vector<vector<int>> B(n, vector<int>(n));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> B[i][j];
        }
    }

    // 计算矩阵乘法
    auto start_time = chrono::steady_clock::now();
    vector<vector<int>> C = matrix_multiply(A, B);
    auto end_time = chrono::steady_clock::now();
    auto duration = chrono::duration_cast<chrono::microseconds>(end_time - start_time);

    // 输出结果和计算时间
    cout << "矩阵乘积为：" << endl;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cout << C[i][j] << " ";
        }
        cout << endl;
    }
    cout << "计算时间为：" << duration.count() << " 微秒" << endl;

    return 0;
}

使用时，先输入矩阵的大小n，然后依次输入矩阵A和B的元素。程序会计算出矩阵A和B的乘积并输出结果和计算时间。

### 回答2：
题目要求用C语言实现输入两个n×n矩阵A和B的乘积运算，并输出运算结果和计算时间。
在C语言中，可以使用二维数组来表示矩阵，并使用循环嵌套的方式实现矩阵乘法运算。具体步骤如下：

1. 首先，声明一个n×n的二维数组A和B，用于存储输入的矩阵A和B。
2. 使用循环语句从用户输入中读取矩阵A和B的元素，并将其存储在数组A和B中。
3. 声明一个n×n的二维数组C，用于存储运算结果。
4. 使用三层循环嵌套，分别遍历C的行数i、列数j和矩阵A和B的列数k。
在每次循环中，计算结果矩阵C的元素C[i][j]，即C[i][j] = A[i][k] * B[k][j]，并将其累加到C[i][j]中。
5. 通过clock()函数获取运算开始和结束的时间，并计算运算时间。
6. 使用循环语句遍历结果矩阵C，将其输出。

以下是C语言程序的示例代码：

#include <stdio.h>
#include <time.h>

int main() {
int n;
printf("请输入矩阵的阶数n：");
scanf("%d", &n);

int A[n][n], B[n][n], C[n][n];
int i, j, k;

printf("请输入矩阵A的元素：\n");
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &A[i][j]);
}
}

printf("请输入矩阵B的元素：\n");
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &B[i][j]);
}
}

clock_t start_time, end_time;
start_time = clock();

for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
C[i][j] = 0;
for (k = 0; k < n; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}

end_time = clock();
double total_time = (double)(end_time - start_time) / CLOCKS_PER_SEC;

printf("矩阵乘法的结果为：\n");
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf("%d ", C[i][j]);
}
printf("\n");
}

printf("运算时间为：%f秒", total_time);

return 0;
}

注意：上述代码中使用了clock()和CLOCKS_PER_SEC宏来计算运算时间，需要添加头文件<time.h>。

希望以上回答对您有帮助，如有疑问请继续追问。

### 回答3：
要用C语言实现输入两个n×n的矩阵A和B，实现乘积运算，并输出运算结果和计算时间，可以按照以下步骤来进行：

1. 首先，需要定义一个函数来进行矩阵的乘法运算。函数的输入参数可以是两个n×n的矩阵A和B，以及一个指向n×n结果矩阵C的指针。函数内部可以使用两个嵌套的循环来实现矩阵的乘法运算。例如，可以用i和j来迭代访问A和B的元素，再用k来迭代计算C的元素。

2. 在主程序中，可以先定义n的值，并且使用动态内存分配来创建三个n×n的矩阵A、B和C。例如，可以使用malloc函数来分配内存。

3. 接下来，可以使用循环结构来输入矩阵A和B的元素值。可以利用嵌套的循环语句来让用户输入矩阵元素的值。

4. 调用定义的矩阵乘法函数，传递矩阵A、B和C的指针作为参数，来计算矩阵乘积。

5. 输出计算结果和计算时间。可以使用clock函数来获取程序运行的时间。首先，在矩阵乘法运算之前调用clock函数，将其返回值保存在一个变量中。在矩阵乘法运算之后再次调用clock函数，将其返回值减去之前保存的值得到运算的时间。最后，将矩阵乘积C的元素值输出到屏幕上。

6. 最后，别忘了释放动态分配的内存，以免造成内存泄漏。可以使用free函数来释放矩阵A、B和C的内存。

通过以上步骤，就可以用C语言实现输入两个n×n的矩阵A和B，实现乘积运算，并输出运算结果和计算时间了。