如何使用向量和整数作为类的构造函数

Question

如果我有一个 foo 类，那么

class foo{
   vector <int> vec;
   int someint;

   public:
   foo(number n): someint(n){}


}

我将如何为 class foo 的 vector 编写构造函数？此外，我可以使用：

int get_someint() const{

  return someint;
}

返回一个 int，但是向量呢？

Answer 1

当使用复杂的数据类型时，通常最好使用引用或常量引用，如下所示：

class A
{
public:
    A()  {}  // default construct of A, v_ is empty

    A(const std::vector<int>& source)
      : v_(source)  // construct A, given a vector that is 
                    // copied into v_
    {
    }

    // returns an immutable reference to v_
    const std::vector<int>& get_v() const
    {
       return v_;
    }

    // returns a mutable reference to v_
    std::vector<int>& get_v()
    {
        return v_;
    }
private:
    std::vector<int> v_;
};

示例用法：

A a_no_vec;  // A has an empty vector v_

std::vector<int> src;

src.push_back(16);
src.push_back(19);

A a_with_vec(src);  // A has a vector that is a copy of src

Answer 2

你也可以这样做。出于所有目的，请将 vector 视为普通变量（例如 int），因此您可以编写：

class foo{
   vector <int> vec;
   int someint;

   public:
   foo(number n, vector<int> v): someint(n), vec(v){}
}

它将被内部和外部复制，并且这可能意味着大量的内存副本。这就是为什么对于如此大的对象，使用按引用传递（通过指针或引用）。例如，要返回向量：

vector<int> const& the_vector()
{ return inner_vector; } // no copy

，构造函数也将是 foo(number n, vectorconst& v)。另外，如果在内部您不必存储向量的副本，则可以使用该向量的指针或引用作为成员，而不是向量副本本身，即类是：（

class foo{
   vector <int>& vec;
   int someint;

   public:
   foo(int n, vector<int>& v): someint(n), vec(v){}
}

注意引用） 。与指针相同。

Answer 3

您不需要为向量编写构造函数。 Vector 已经有了它的构造函数。您也可以在返回 int 时简单地返回一个向量，例如

const std::vector<int> & getVec()
{
   return vec;
}