堆栈内存溢出
  繁体   English   中英

不同初始化方式的构造函数

[英]Constructors for different ways of initialisation

 原文  2022-01-24 15:08:24  6   4    c++/ class/ constructor

问题描述

我在 class 矩阵上编写代码。 所以我在理解如何使用构造函数方面有一点困难。 其实我对默认构造函数和参数化构造函数特别怀疑。

class 的默认构造函数： Matrix() 将行和列以及矩阵元素初始化为零。

参数化构造函数：Matrix(int rows, int columns) 初始化传递的值，以及默认值为 0 的二维矩阵元素。

我不知道这两个构造函数是如何工作的。 不要 class 只有一个构造函数，或者它可以有多个构造函数。 我知道如何编写默认构造函数以及如何编写参数化构造函数。 当我们在同一个 class 中编写这两个构造函数时，帮助了解这两个构造函数是如何工作的。 这行得通吗？

class Matrix{

  private:
  int rows;
  int columns;
  int **mat;

public:
Matrix(int row, int column){
    this->rows = row;
    this->columns = column;
    mat = new int *[row];
    for(int i=0;i<rows;i++){
       mat[i]=new int[column];    
      }
    }
 };

4 个解决方案

解决方案1
 2  2022-01-24 15:24:33

你的代码有很多错误。 当rows和columns仅在运行时已知时，您不能将它们用作数组大小。 即使您可以使用row和columns作为数组大小，在为它们分配任何值之前，您也将它们用作数组的大小。 此外this->mat[rows][columns]={0}; 试图访问一个超出数组边界的元素，它会调用未定义的行为。 对动态大小的 arrays 使用std::vector 。

是的，class 可以有多个构造函数。 调用哪个构造函数由 重载决议决定。 在下面的例子中，要调用的构造函数可以简单地由传递的参数个数决定。 通常，重载解决方案更复杂（并且超出了此答案的 scope）。

#include <vector>
#include <iostream>

struct Matrix {
    int rows;
    int columns;
    std::vector<std::vector<double>> data;
    Matrix() : rows(0),columns(0) {}

    Matrix(int rows,int columns) : rows(0),columns(0),data(rows,std::vector<double>(columns)) {}
};

int main() {
    Matrix m1;
    std::cout << m1.data.size() << "\n";
    Matrix m2{5,10};
    std::cout << m2.data.size() << "\n";
    std::cout << m2.data[0].size() << "\n";
}

请注意， std::vector也有多个构造函数： https://en.cppreference.com/w/cpp/container/vector/vector 。 Matrix()使用向量默认构造函数 (1) 创建一个空向量。 data(rows,std::vector<double>(columns))通过调用采用大小和值 (3) 的向量构造函数，使用向量的向量初始化data 。

术语“参数化构造函数”是用词不当。 “参数化构造函数”和默认构造函数之间的区别是错误且具有误导性的。 可以同时对构造函数和默认构造函数进行参数化。 默认构造函数是可以不带参数调用的构造函数。 这可能是因为它没有 arguments 或因为它具有默认 arguments。 例如上面两个可以等价地写成：

Matrix(int rows=0,int columns=0) : rows(0),columns(0),data(rows,std::vector<double>(columns)) {}

这是一个默认构造函数，它是参数化的，因为它可以用以下两种方法之一调用：

Matrix m1;
Matrix m2{5,10};

但是，也可以通过调用带有默认参数的构造函数

Matrix m3{42};

这可能是不可取的。 因此，更好的选择可能是（如 Caleth 所述）：

struct Matrix {
    int rows;
    int columns;
    std::vector<std::vector<double>> data;

    Matrix(int rows,int columns) : rows(0),columns(0),data(rows,std::vector<double>(columns)) {}
    Matrix() : Matrix(0,0) {}
};

这使用委托构造函数来避免重复某些代码（自 C+11 起可用）。

PS：向量的向量不是特别好的数据结构。 std::vector的优势在于其数据的局部性，但这在std::vector<std::vector<double>>中丢失了。 std::vector<double>中的双精度数存储在连续的 memory 中。 但是std::vector<std::vector<double>> double的 double 并非全部存储在连续的 memory 中。 那是因为元素没有存储在向量中。 通常，最好将平面std::vector<double>也用于 2D 情况，并通过索引转换模拟第二维。

解决方案2
 0  2022-01-24 15:26:24

是的，对于给定的 class，我们可以有多个构造函数。 这在下面给出的示例中进行了说明。

第二个注意，在标准 C++ 中，an 的大小必须是编译时间常数。 所以当你写：

int mat[rows][columns];//THIS IS NOT STANDARD C++

以上说法不符合标准C++。

更好的方法是使用 2D std::vector ，如下所示。 您可以将此示例用作参考。

#include <iostream>
#include <vector>
class Matrix{

    private:
    
    std::size_t rows;
    std::size_t columns;
  
    //use a std::vector instead of array
    std::vector<std::vector<int>> mat;

    public:
        //default constructor
        Matrix(): rows(0), columns(0), mat()  //this uses constructor initiailzer list
        { 
            
        }
        //parameterized constuctor
        Matrix(std::size_t pRows, std::size_t pColumns): rows(pRows), columns(pColumns), mat(rows, std::vector<int>(columns))//this also uses constructor initiailzer list
        {
            
        }
        
        //member function to display columns and rows of the matrix
        void display()
        {
            
            for(auto &r: mat)
            {
                for(auto &element: r)
                {
                    std::cout<<element<<" ";
                }
                std::cout<<std::endl;
            }
            std::cout<<"--------"<<std::endl;
        }
};
int main()
{
    Matrix m1; //this uses default constructor 
    m1.display();
    
    Matrix m2(5,7);//this uses parameterized constructor
    m2.display();
    return 0;
}

我所做的一些修改包括：

  1. 添加了使用构造函数初始化列表的默认构造函数。
  2. 添加了使用构造函数初始化列表的参数化构造函数。
  3. 添加了一个display() function 打印出矩阵内的所有元素（行和列）。
  4. 创建了一个 object m1 ，它使用默认构造函数来初始化其数据成员rows 、 columns和mat 。
  5. 创建了一个 object m2 ，它使用参数化构造函数来初始化其数据成员rows 、 columns和mat 。

解决方案3
 0  2022-01-24 15:36:26

我想向您指出任何 C++ 书。

class 可以有任意数量的构造函数，因为它们的签名（数量、类型和参数的顺序）都不同。

您的 class 有一个构造函数，它是默认构造函数。 它只能创建零维矩阵。

使用this->访问数据成员是可选的，我认为实际上并没有多少开发人员使用它。

我假设，您不想动态更改矩阵的维度（希望如此），所以我建议将成员rows和columns设为const 。

而且，您必须意识到：C++ 不是解释性语言。 它在一天编译并在另一天运行。 编译器不知道哪些值将用于rows和columns ，因此在成员声明中使用这些维度将不起作用。 大多数时候编译器会抱怨数组的非常量维度。

您有几种可能性：在运行时确定要使用的维度或在编译时确定。 每个都有其优点和缺点。 我想对于一个绝对的初学者来说，运行时方法看起来更容易，但编译时方法要快得多。

class matrix_runtime
{
public:
    matrix_runtime(int r, int c)
        : rows(r), columns(c)
    {
        mat = std::make_unique<int[]>(rows*columns);
    }
private:
    int const rows{};
    int const columns{};
    std::unique_ptr<int[]> mat;
};

template<size_t Rows, size_t Columns>
class matrix_compiletime
{
public:
    matrix_compiletime() = default;
public:
    std::array<int, Rows * Colums> mat;
};

如果您在编译时知道要使用哪些维度，我强烈建议您使用编译时版本。 具有不同维度的矩阵将是不同的类型（这就是矩阵的重点，不是吗？），因此如果您尝试，编译器将通过给您错误来帮助您避免错误。

这是我使用的标准库的一些文档：

如果你想了解 C++ 初始化： https://en.cppreference.com/w/cpp/language/initialization

解决方案4
 0  2022-01-24 16:50:52

您的代码中有很多更基本的问题：

int rows;
int columns;
int mat[rows][columns];

是 C++ 中动态数组的非法定义。 数组大小需要是 C++ 中的编译时间常数，但rows和columns不是（如果您同时使用const ，这甚至不会改变，因为 class 的不同实例可能使用不同的值。

即使它是合法的，在您的默认构造函数中，您也会在构造函数中越界访问 arrays：

mat[rows][columns] = ...

数组大小为 0（这在 C++ 中也是非法的）在 arrays 中没有可访问的索引 0。

所以在我们可以 go 之前，我们首先需要解决这些问题。 根据您的需要，有多种选择。

一个非常简单的方法是在std::vector的std::vectors中维护数据：

class Matrix
{
    std::vector<std::vector<int>> mat;
public:
    // ...
};

向量隐式存储有关其内部大小的信息，因此以前的rows和columns成员（正确的类型本来应该是size_t ，而不是int ）是多余的，可以而且应该删除以支持使用来自向量的信息的函数：

size_t rows() { return mat.size(); }
size_t columns() { return mat.size() == 0 ? 0 : mat[0].size(); }

我在这里假设所有行的大小相同，如果不是（即锯齿状数组），我们无法将其应用于列。

向量的向量是实现动态矩阵的一种非常方便的方法，但是会带来矩阵元素访问的双重间接成本，需要额外的数组（对您来说是透明的，但您需要它来存储行）并且必须单独分配列（再次对您透明）。

如果您基于一维数组实现矩阵，您将获得更高的效率：

size_t m_columns;
std::vector<int> mat;

现在您需要单独存储列，并且需要显式计算正确的偏移量到矩阵中：

size_t rows() { return mat.size() / m_columns; }
size_t columns() { return m_columns; }
int& at(size_t x, size_t y) { return mat[x * m_columns + y]; }

请注意，您仍然可以提供m[x][y]语法，替换at的语法，但这会变得相当复杂，所以我暂时将其省略。 但是，优点是单一间接，因此访问速度更快，不需要额外的 memory 和对所有 memory 的单一分配，因此再次更快。

另一种方法是以模板参数的形式提供恒定的数组大小：

template<size_t Rows, size_t Columns>
class Matrix
{
   int mat[Rows][Columns];
};

这带来了对数组元素的最快访问和最高的类型安全性，因为您可以提供用于转置、加法、乘法等的运算符，以使您无法将错误维度的矩阵传递给。 另一方面，您失去了很大的灵活性，例如，您不能将不同维度的矩阵直接放入同一个容器（向量、列表或其他）中，因为具有不同参数的模板形成不同的类型（虽然有一些方法，但不太方便，基于多态性）并且需要在代码中已经指定类型的大小，即您不能动态计算矩阵大小。

两种方法都有用例（基于动态分配和静态类型矩阵），您需要根据您的具体要求 select。 对于第一个 go，我推荐双向量方法，因为它很简单，尽管它有其他缺点。 一旦它起作用，您可能会切换到一维数组方法......

现在关于您的实际问题：

您始终可以重载构造函数，即提供多个参数数量和/或类型不同的构造函数； 然后将根据您提供的 arguments 选择最合适的一个（尽管在某些特定情况下可能会出现歧义）。

在您的情况下，您将提供：

Matrix();
Matrix(size_t rows, size_t columns); // not needed in the template variant,
                                     // dimensions are given via
                                     // template parameters

但是，您应该使用构造函数的初始化列表（不要与 std::initialiser 列表混淆），它可能如下所示：

Matrix() : /*rows(0), columns(0),*/ mat() { }

请记住，我删除了行和列的成员，因此它们也不会再出现在构造函数中，我将它们留在评论中以说明如果我没有这样做会是什么样子。 请注意， mat()调用向量的默认构造函数，该构造函数创建一个空的。 显式调用它是可选的，您可以忽略它，然后它会被隐式调用。

使用std::vector你很幸运：它提供了一个构造函数，其中包含要初始化的元素数量以及将用于所有元素的可选默认值； 所以我们可以简单地写：

Matrix(size_t rows, size_t columns) : mat(rows, std::vector<int>(columns)) { }

而已...

您的完整 class 可能如下所示（结合上面的所有信息）：

class Matrix
{
    std::vector<std::vector<int>> mat;
public:
    Matrix() = default; // short hand syntax...
    Matrix(size_t rows, size_t columns) : mat(rows, std::vector<int>(columns)) { }

    size_t rows() { return mat.size(); }
    size_t columns() { return mat.size() == 0 ? 0 : mat[0].size(); }

    // still providing `at` function as returning a reference to
    // a row vector would allow to modify that one e. g. in size
    // and thus create an invalid matrix!
    int& at(size_t x, size_t y) { return mat[x][y]; }
};

你现在可能会停在这里，但实际上我们还没有结束。 一旦你完成工作（请尝试自己实现，不要只是复制/粘贴，你不会从中学到任何东西），你可以回到这里进行下一步：

class Matrix
{
    std::vector<std::vector<int>> mat;
public:
    Matrix() = default; // short hand syntax...
    Matrix(size_t rows, size_t columns) : mat(rows, std::vector<int>(columns)) { }

    size_t rows() const { return mat.size(); }
    size_t columns() const { return mat.size() == 0 ? 0 : mat[0].size(); }

    // still providing `at` function as returning a reference to
    // a row vector would allow to modify that one e. g. in size
    // and thus create an invalid matrix!
    int at(size_t x, size_t y) const { return mat[x][y]; }
    int& at(size_t x, size_t y) { return mat[x][y]; }
};

你注意到const关键字了吗？ 它们允许访问声明为const的实例，即不可修改。 您应该声明所有不修改 object 的成员函数const 。

对于at我提供了两个版本 - const 一个只返回一个值，这样就不可能（非法）修改矩阵，而非常量一个引用可以更改矩阵元素。

在这种情况下，重载解决方案非常简单： const矩阵上的const const上的非const重载：

Matrix m(1, 1);
Matrix const& mr = m; // const reference!
m.at(0, 0);  // non-const at
mr.at(0, 0); // const at
m.rows();    // can call const functions on non-const objects, if there's
             // no non-const overload – but not the other way round

到目前为止的基础。 如果您对Matrix class 的m[x][y]语法感兴趣，请发表评论，我可能会添加一些额外的行；）

暂无
暂无

声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

相关问题 C++中不同的数据初始化方式 使用C ++构造函数的不同方法 尝试初始化结构的构造函数中的初始化列表 明确默认的构造函数和成员变量的初始化 使用初始化列表来处理使用不同初始化方法的对象？ 在运行时使用不同的构造函数 FILE *在不同功能中的初始化c ++ 制作内核的不同方法 实现原子的不同方式* = 不同的实例化方式
相关标签
 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM