C++ 如何在c++；参考O（1）？

我希望将类作用域别名设置为参数中的向量

例如：

class Solution {
private:
     vector<int> b; // I want that &b = a, where a from function solve
     int f(int i) {
          // here I want to use vector<int> a, 
          // not passing it as a function argument every time
     }
public:
     int solve(vector<int>& a) {
          // here I want to do smth like b = a; which works for O(1)
     }
};

类解决方案{
私人：
向量b；//我想要&b=a，其中a从函数开始求解
int f（int i）{
//这里我想用向量a，
//不是每次都将其作为函数参数传递
}
公众：
整数求解（向量&a）{
//这里我想做smth，比如b=a；它适用于O（1）
}
};

不幸的是，我不能只声明

vector&b，由于错误：
引用变量“b”的声明需要初始值设定项

你能解释一下如何在C++11/14中实现它吗

更新：我无法更改
intsolve（vector&a）
的声明，该接口由外部提供

更新：我已将代码更改为更明确的代码。看起来我不应该再这样做了，因为在答案和注释中，人们使用原始变量名。对不起，我对StackOverflow没有太多经验
 也许是这个

class Solution {
public:
     vector<int> a;
     int maxCoins(const vector<int>& _a) { // const because copying
          a.assign( _a.begin(), _a.end() );
     }
};

类解决方案{
公众：
载体a；
int maxCoins（常量向量&_a）{//const因为复制
a、 赋值（_a.begin（），_a.end（））；
}
};

但要知道，如果您希望引用原始
向量而不是副本，也可以这样做：

class Solution {
public:
     vector<int> & a;
     int maxCoins(vector<int>& _a) : a( _a ) {}
};

类解决方案{
公众：
向量&a；
int-maxCoins（向量&_-a）：a（_-a）{
};


更新
这可能是最接近的。您不能重新初始化引用，但这正是指针的用例

class Solution {
public:
     vector<int> * a;
     int f(int i) {
         a->size(); // can access indirectly
         (*a)[1]; // element access is slightly trickier
         vector<int> & _a = *a; // or can create a direct ref
         _a.size();
     }
     int solve(vector<int>& _a) {
         a = &_a; // store address to _a. a reference is like any local variable unless doing something funny
     }
};

类解决方案{
公众：
向量*a；
int f（int i）{
a->size（）；//可以间接访问
（*a）[1]；//元素访问稍微复杂一些
向量&_a=*a；//或可以创建直接引用
_a、 大小（）；
}
整数解算（向量和a）{
a=&_a；//指向_a的存储地址。除非做了一些有趣的事情，否则引用就像任何局部变量一样
}
};


更新2-不使用指针
#包括
类解决方案{
公众：
//载体a；
typedef向量数据类型；
数据类型blankref；
std:：reference_wrapper a=blankref；
int f（int i）{
向量a=a；
}
整数解算（向量和a）{
a=标准：：参考（_a）；
}
};

您无法避免引用只分配一次的事实。类实例中的引用必须使用初始值设定项语法进行分配。要有一个可重用的引用，每次都需要有一个新初始化的对象

为了帮助我们，感谢注释中的建议，有一个
std:：reference\u包装器
类型可以保存引用的实例。可以将其分配为重复使用
std:：ref（_a）

老实说，指针在正确使用时并不是不雅观的，依我看，这取决于用例和您认为需要的东西。就性能而言，这可能不如指针好（因为正在构造临时对象），尽管不能保证。。。在任何情况下，它都应该执行类似的操作。
allice是什么意思？对不起，alias没有戴眼镜就看不到打字错误。因此，如果有人在调用
solve
之前调用
f
会发生什么情况？也许
f
完全是从
solve
内部调用的。从“每次不将其作为函数参数传递”开始，考虑到“我不能更改
int solve（vector&_a）
的声明，从外部提供的接口”-我收集
solve
是入口点，并且给定的
\u a
没有任何其他方法可用（已建议），
f
似乎是要从
solve
内部使用，否则您如何在
f
中接收
a
？是的，您是对的。让我更改密码。谢谢你的回答！1） 由于赋值，因此适用于O（n），并且我无法更改
solve/maxCoins
函数的声明。2） 编译器返回错误：
只有构造函数使用成员初始值设定项
我认为不能在O（1）中复制
向量。复制构造函数/赋值操作将分别复制每个元素（如果它们是类怎么办？），否则您将使用
std:：swap
来交换两个向量的内容。您的用例是什么，您需要类中临时可访问的
a
（原始值）还是需要副本来使用？如果您只需要访问，我建议使用指针或RAII/令牌对象，否则，由于
vector
的复制方式，您只能使用O（n）。是的，您是对的，我并不真正需要vector的另一个副本，我需要的是引用副本，它实际上是同一块内存的别名。我知道如何使用指针，但我一直在寻找更优雅的方式。我已经更改了问题描述。抱歉，没有明确的标题。有一种方法可以避免指针，如果您认为它会有帮助，可以演示如何使用，但它需要创建一个新的结构/类。值得的？（有时）
#include <functional>

class Solution {
public:
     // vector<int> a;
     typedef vector<int> datatype;
     datatype blankref;
     std::reference_wrapper<datatype> a = blankref;
     int f(int i) {
          vector<int> & _a = a;
     }
     int solve(vector<int>& _a) {
          a = std::ref(_a);
     }
};