用c++写一个使用智能指针 创建一个二维vector指针对象的例子

示例代码：
#include <iostream>
#include <memory>int main()
{
// 创建一个二维vector指针
std::unique_ptr<std::vector<std::vector<int>>> vec2d_ptr(new std::vector<std::vector<int>>()); // 使用智能指针添加一维vector
vec2d_ptr->push_back(std::vector<int>()); // 添加一维vector中的元素
vec2d_ptr->at(0).push_back(10);
vec2d_ptr->at(0).push_back(20);
vec2d_ptr->at(0).push_back(30); // 打印元素
for (const auto &vec : *vec2d_ptr) {
for (const auto &val : vec)
std::cout << val << " ";
std::cout << std::endl;
} return 0;
}

相关问题

c++ 二维vector

二维vector指的是一个二维的可变长数组，可以动态地进行元素的添加、删除、修改、查找等操作。在C++中，可以通过嵌套vector实现二维vector，也可以使用数组和指针等数据结构来实现。

使用vector实现二维数组，需要先声明一个vector<vector<数据类型>>的变量，其中数据类型可以是任何类型，比如int、char、double等。然后可以通过push_back()方法来添加元素，使用size()方法获取向量的大小，使用at()方法访问元素，使用erase()方法删除元素等。例如，vector<vector<int>> a; a.push_back({1,2,3}); a.at(0).push_back(4); a.erase(a.begin()+1)等操作可以实现向二维vector中添加、修改和删除元素。

相比于二维数组，二维vector的好处是可以动态调整大小，不必提前指定大小，当然也需要注意效率问题。此外，由于嵌套vector实际上是一个动态数组的数组，所以它可以更好地处理不规则数组以及高维数组。在编写涉及多维数组的程序时，使用二维vector可以让代码更加简洁、易读和易于维护。

总之，二维vector是一种非常有用的数据结构，它能够有效地处理多维数组及动态调整大小的需求，是C++中的常用数据结构之一。

编写一个c++方法不能用vector，只能使用指针，实现一个下三角矩阵和一个上三角矩阵的乘法，这两个矩阵都是按行的方式储存在一维数组中。结果矩阵用二维数组表示。计算时间复杂度

在C++中，如果你需要使用指针而不是`std::vector`来存储矩阵并实现下三角矩阵（Lower Triangular Matrix, LTM）和上三角矩阵（Upper Triangular Matrix, UTM）的乘法，可以考虑使用动态内存分配来创建一维数组，并利用指针操作。由于矩阵乘法规则，下三角矩阵乘上三角矩阵的结果只会在对角线及其上方的部分有值，所以不需要遍历整个矩阵。

首先，假设我们有两部分别表示LTM和UTM的一维数组，每个元素都对应矩阵的一个元素。我们可以创建一个二维数组用于存放结果。下面是一个简单的示例：

#include <iostream>

// 定义一个函数接受两个一维数组（LTM和UTM），指针指向它们的首元素，以及矩阵的行数和列数
void multiply(int* ltm, int* utm, int* result, int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j <= i; ++j) { // 只遍历对角线及上方的元素
            result[i * cols + j] = 0;
            if (j > 0) {
                result[i * cols + j] += ltm[i * cols + j - 1] * utm[j - 1];
            }
            result[i * cols + j] += ltm[i * cols + j] * utm[i]; // 如果i == j，加上当前行对应的元素
        }
    }
}

// 为了方便演示，这里仅提供打印二维数组的辅助函数
void printMatrix(int (*matrix)[cols], int rows, int cols) {
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j)
            std::cout << matrix[i][j] << " ";
        std::cout << "\n";
    }
}

int main() {
    const int rows = 4;
    const int cols = 4;

    int* ltm = new int[rows * cols];
    int* utm = new int[rows * cols];
    int* result = new int[rows * cols];

    // 初始化你的LTM和UTM一维数组...
    // 这里省略了初始化步骤

    multiply(ltm, utm, result, rows, cols);

    // 打印结果矩阵
    printMatrix(result, rows, cols);

    delete[] ltm;
    delete[] utm;
    delete[] result;

    return 0;
}

这个算法的时间复杂度是O(rows^3)，因为有两个嵌套循环遍历矩阵，外部循环遍历的是行，内部循环最多遍历到当前行的索引。然而，由于实际计算涉及的元素比完全的平方矩阵少，所以在某些特定场景下，实际运行效率可能会更高一些。