在构造函数中将非常量左值绑定到右值时出错
是因为在C++中，非常量左值不能绑定到右值引用。
右值引用是C++11引入的一种新的引用类型，用于绑定临时对象（右值）。右值引用的语法是使用双引号&&来声明，例如int&&。
在构造函数中，如果将一个非常量左值绑定到右值引用参数时，编译器会报错。这是因为右值引用通常用于移动语义，即将资源从一个对象转移到另一个对象，而非常量左值是具有持久性的对象，不能被移动。
解决这个问题的方法是使用const修饰左值参数，或者使用左值引用作为参数类型。const修饰的左值参数可以接受右值和左值，而左值引用可以接受左值。
以下是一个示例代码：
class MyClass {
public:
MyClass(const int& value) {
// 构造函数中将非常量左值绑定到右值时不会出错
}
};
int main() {
int x = 10;
MyClass obj(x); // 使用非常量左值作为参数，会出错
return 0;
}在上面的示例中，将非常量左值x作为参数传递给MyClass的构造函数时，会导致编译错误。要解决这个问题，可以将构造函数的参数类型改为const int&或int&。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数（云函数）：https://cloud.tencent.com/product/scf
- 腾讯云云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 腾讯云容器服务（TKE）：https://cloud.tencent.com/product/tke
- 腾讯云数据库（TencentDB）：https://cloud.tencent.com/product/cdb
- 腾讯云对象存储（COS）：https://cloud.tencent.com/product/cos
- 腾讯云人工智能（AI）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 腾讯云移动开发（移动推送）：https://cloud.tencent.com/product/tpns
- 腾讯云区块链（BCS）：https://cloud.tencent.com/product/bcs
- 腾讯云元宇宙（Tencent XR）：https://cloud.tencent.com/product/xr
相关·内容
在C++中，将右值隐式转换为左值引用是非法的。考虑以下代码，其中一个左值引用绑定到一个右值( lambda)：
int main()
{
auto& f = []() -> void {};
return 0;
}
gcc (4.8.1)不接受这样的代码(完全有道理)。然而，微软编译器确实接受它，这意味着它要么接受非标准代码，要么C++允许左值引用绑定到右值lambda表达式的特殊情况。
问题是:哪个假设是正确的？
浏览 0提问于2013-06-16得票数 6
回答已采纳
2回答
如果我没有错，我认为常量引用和右值引用都可以绑定到右值。返回前者的函数和返回后者的函数有什么实际区别吗？
编辑。我不能修改前者，但为什么我会对修改右值感兴趣？这有意义吗？
浏览 3提问于2013-03-28得票数 7
回答已采纳
1回答
我正在阅读c++中的移动语义，并遇到了以下示例作为动机：
template<class T>
void swap(T& a, T& b)
{
T tmp(std::move(a));
a = std::move(b);
b = std::move(tmp);
}
这里说，如果T没有实现移动语义(在复制构造函数和赋值操作符中)，那么swap将表现为“正常”的swap：
template<class T>
void swap(T& a, T& b)
{
T tmp(a);
a = b;
b = tmp;
浏览 2提问于2017-10-02得票数 2
class sampleConstructor {
int x;
public:
//WE COULD DO OVERLOAD CONSTRUCTOR JUST LIKE IN FUNCTIONS | THEY ONLY DIFFERENTIATE IN NO. OF ARGUMENTS AND DATATYPE OF ARGUMENTS JUST LIKE IN FUNCTION
sampleConstructor () { //THIS IS THE DEFAULT CONSTRUCTOR, THIS WILL AUTOMATICALLY INITIALIZE EVERYTHING
浏览 16提问于2021-04-11得票数 0
3回答
从命名空间中返回对象是否安全。在下面的代码中，call()按值返回bag对象。但是新创建的对象的作用域在命名空间内...所以我怀疑这是不是正确的方法。
namespace abc{
class bag{
public:
bag()
{
cout<<"\nconstructor called";
}
~bag()
{
cout<<"\ndestructor called";
}
浏览 0提问于2013-06-26得票数 0
4回答
可能重复：
C++标准主要在第五章“表达式”中定义了哪些表达式是左值，哪些表达式是右值。我已经读过这一章，我相信我可以正确地区分左值和右值。
然而，在我读过好的C++书籍和/或标准之前，我曾经认为左值是可以位于赋值左侧的东西，而右值是不能的东西。显然，对于这个天真的定义，有许多反例。一段时间后，我认为左值是有地址的东西，而右值是没有地址的东西。这似乎也有反例，比如说，一些临时对象，显然是有地址的。
我的一个朋友问我什么是左值，什么是右值。我告诉他大概是什么，他要求一个更完整的答案。我让他去看看标准。他拒绝骚扰自己的大脑，并说他确信一定有一些充要条件使某些东西成为左值。
在那里吗？
例如，
浏览 53提问于2011-06-19得票数 25
回答已采纳
1回答
在使用lambdas时，我遇到了一个有趣的案例(至少对我来说是这样)，我想知道这是编译器的bug还是标准特性允许的东西。
让我们开门见山吧。拥有示例代码：
const int controlValue = 5;
std::vector<int> vect{ 0, 1, 2, 3 };
const auto result = std::any_of(vect.begin(), vect.end(), [](const int& item)
{
return item == controlValue;
});
注意，拉姆达表达式没有捕获controlValue变量。此外
浏览 55提问于2017-03-30得票数 16
回答已采纳
1回答
我们只能将引用绑定到对象，而不能绑定到文字或更genreal表达式的结果。
int i=42;
double d=1.2;
int &r=10;//error:initializer must be an object.
int &r1=d; //error: initializer must be an int object
虽然我们可以将对常量的引用绑定到对象，但将文字绑定到更通用表达式的结果，如下所示-
int j=45;
double d=1.2;
const int &r2=j; // works
const int &r2=60; //works
c
浏览 0提问于2016-06-09得票数 1
我正在使用以下用于调试输出的遗留代码模式。我知道这不是打印调试消息的最有效的方法，但我的问题涉及到更基本的问题。这似乎是一个基本的问题，但它挑战了我对编译器如何解释指定为按常量引用传递的函数参数的理解。
遗留代码中的调试消息模式如下所示：
#include <iostream>
#include <cctype>
#include <cstring>
#include <stdio.h>
void debugMsg(const std::string& testStringRef){
printf("%s\n"
浏览 2提问于2018-12-04得票数 0
将左值引用作为右值引用参数传递不能编译。编译器可以使用其复制构造函数创建一个临时对象，并将其作为右值传递，但它不能。但是，如果类型不匹配，它会调用构造函数。
我很感兴趣，为什么会这样呢？在C++标准中，哪种设计逻辑迫使编译器以不同的方式处理复制构造函数？
void do_smth(string && s)
{}
void f(const char * s)
{
do_smth(s); // passes a temporary string constructed from const char*
}
void g(const string & s)
{
d
浏览 0提问于2019-01-30得票数 2
我试图给我的std::thread参数列表一个函数指针，但我得到了一堆我不理解的编译错误(@ MSVC\14.28.29333\include\thread(43,14): error C2672: 'invoke' : fonction correspondante surchargée introuvable [overloaded function not found])。
我可以写一个mcve给出同样的错误。
#include <thread>
#include <vector>
template<typename T>
void
浏览 27提问于2021-02-19得票数 3
回答已采纳
我知道在c++03中，非常数引用不能绑定到右值。
T& t = getT();是无效的，在c++11中，我们可以这样做：T&& t = getT();，但是上面的代码怎么办，它应该在c++11中工作吗？
我用vs11测试了以下代码：
Foo getFoo() {
return Foo();
}
void fz(Foo& f) {
}
int getInt() {
return int();
}
void iz(int& i) {
}
int main() {
{
Foo& z = getFoo(); //ok
浏览 0提问于2013-05-11得票数 6
回答已采纳
1回答
考虑以下类。如果我自己实现了move构造函数，为什么不移动而是复制bar成员b？但是如果我使用默认的move构造函数，那么b就会被移动。为什么b(rhs.b)不给bar(bar&&)打电话？
我使用带有--std=c++11的g++ 9.2.1。
class bar {
public:
bar() { cout << "bar constructor" << endl; }
bar(const bar& rhs) { cout << "bar copy constructor" <
浏览 8提问于2020-10-14得票数 3
2回答
我正在通读这篇关于“五条规则”的，我注意到了一些我以前没有见过的东西：
class C {
...
C& operator=(const C&) & = default;
C& operator=(C&&) & = default;
...
};
对于复制赋值操作符和移动赋值操作符，放置在= default前面的&字符的用途是什么？有没有人对此有参考？
浏览 7提问于2012-09-07得票数 51
回答已采纳
为什么fun(p)可以工作，而fun(&i)不能？ #include<iostream>
using namespace std;
void fun(int*& pp)
{
}
int main()
{
int i;
int *p;
fun(p);
fun(&i); // not working... why?
}
浏览 13提问于2020-05-01得票数 3
回答已采纳
人们倾向于说pass by (const) reference if you want speed，老实说，我很少在我创建的方法上使用const引用，只是因为速度原因，我只在需要的时候引用它，例如给变量赋值，就像在这个SSCE中一样
void Do( int& iref )
{
a = 2;
}
{
int a = 0;
Do( a );
}
实际上，问题是，如果对象是在函数调用中创建的，如果它也会作为引用传递，这是如何工作的？
void Add( CString& strPath )
{
g_Path.push_back( strPath )
浏览 0提问于2012-10-13得票数 0
回答已采纳
我想知道C++是否有某种方式自动转换我想要赋值给引用的值。
class X{
public:
X(int x){
}
};
int main(){
X x = 5; //works
X& y = 6; //doesn't work
X& z = (X)7; //works
return 0;
}
正如您所看到的，如果不对引用y进行强制转换，则将6赋给它是不起作用的。我是否可以在类X的定义中添加一些东西，使其在没有强制转换的情况下工作，以便非工作行可以工作？
基本上，我想要实现这一点，例如像
浏览 0提问于2013-04-20得票数 1
回答已采纳
编译器不喜欢下面的主程序
int get1(ifstream &f){
int count;
f >> count;
return count;
}
int main(int argc, char** argv){
cout << get1(ifstream(argv[1])) << endl;
}
错误消息为：
test.cpp: In function 'int main(int, char**)':
test.cpp:11:33: error: invalid initialization of non-const
浏览 2提问于2013-05-18得票数 3
回答已采纳
有人概括了"Temporaries are rvalues“这句话。我说“不”，并给了他下面的例子
double k=3;
double& foo()
{
return k;
}
int main()
{
foo()=3; //foo() creates a temporary which is an lvalue
}
我的解释正确吗？
浏览 0提问于2010-07-09得票数 1
回答已采纳
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <functional>
#include <deque>
using namespace std;
#include <tr1/functional>
using namespace std::tr1::placeholders;
template<class Function_t>
void for_each_x(Fun
浏览 0提问于2009-11-05得票数 0
回答已采纳
2回答
我有重载的方法：
template<typename AnyType>
void AnyFunc(AnyType &t);
template<typename AnyType>
void AnyFunc(AnyType &&t);
MyType* ptr=new MyType();
AnyFunc(*ptr);
最后一行遇到编译错误: AnyFunc的二义性重载
如何选择我需要的功能？简单的情况是使用：
AnyFunc(std::move(*ptr));
我需要void AnyFunc
浏览 0提问于2012-12-01得票数 1
回答已采纳
以下代码无法编译：
#include <iostream>
using namespace std;
int x = 5;
int && f () { return std::move(x); }
int g(int & y) { return y; }
int main() {
g(f());
return 0;
}
我很清楚为什么prvalue(未命名的临时值)不绑定非常量左值引用--修改它们是没有意义的，因为它们很快就会消失。然而，为什么xvalue不绑定到非常量左值引用？
如果一个函数返回int &&，那么被引用的
浏览 2提问于2015-12-28得票数 2
1回答
代码如下：
namespace NS
{
class B
{
public:
template<typename T> friend B& operator<<(B& b, T const& obj);
};
template<typename T> B& operator<<(B& b, T const& obj)
{
// using b and obj
return b;
}
}
int
浏览 2提问于2017-03-12得票数 0
1回答
下面是这段代码：
#include <iostream>
class F {
public:
F() = default;
F(F&&) {
std::cout << "F(F&&)" << std::endl;
}
F(F&) {
std::cout << "F(F&)" << std::endl;
}
};
class G {
F f_;
public:
G(F&&
浏览 2提问于2013-03-10得票数 6
回答已采纳
3回答
我注意到将char赋值给const int&会进行编译，但是将其赋值给int&会导致编译错误。
char c;
int& x = c; // this fails to compile
const int& y = c; // this is ok
我知道这样做不是一种好的做法，但我很好奇为什么会发生这种情况。
我通过查找“赋值给不同类型的引用”、“将字符赋值给整型引用”和“常量引用和非常数引用之间的差异”来寻找答案，并遇到了一些有用的帖子(、、、)，但它们似乎没有解决我的问题。
如果这个问题之前已经回答过了，我很抱歉。
浏览 2提问于2012-12-09得票数 10
回答已采纳
1回答
在下面的代码中，为什么第一个调用解析为catchClass(aClass&)，并在第二个调用catchClass(const aClassCatcher&)中将临时作为参数
#include <iostream>
using namespace std;
class aClassCatcher{};
class aClass{
public:
operator aClassCatcher(){
return aClassCatcher();
}
};
void catchClass(aClass&){
cout
浏览 3提问于2013-06-09得票数 3
回答已采纳
#include <vector>
#include <iostream>
using namespace std;
int main()
{
vector<int> coll;
decltype(std::begin(std::declval<vector<int>>()))
pos_1 = coll.begin();
auto pos_2 = coll.begin();
cout << typeid(decltype(pos_1)).name() <<
浏览 52提问于2017-03-03得票数 18
回答已采纳
2回答
将右值绑定到常量左值引用
、、、
由于某种原因，我没能找到这个确切的问题。为什么允许将rvalue绑定到const lvalue reference，尽管没有const是不可能这样做的
我确实理解rvalue的生存期以某种方式得到了扩展(在第一种情况下)，但是如果是这样的话，为什么编译器不允许更改那个'rvalue'，它不再是一个真正的临时对象了。
例如，考虑以下代码：
int main(){
int &i=3; //produces error
const int&j =3; //compiles
return 1;
}
浏览 0提问于2016-11-30得票数 16
4回答
组合复制和移动的两个构造函数
、、、、
目前，我的一个玩具类模板有两个看起来非常相似的构造函数：
optional(const T& x)
{
construct(x);
}
optional(T&& x)
{
construct(std::move(x));
}
我可以将它们组合成一个构造函数模板吗，或者这会以某种方式改变语义吗？
template<typename U>
optional(U&& x)
{
construct(std::forward<U>(x));
}
浏览 0提问于2011-09-12得票数 7
回答已采纳
2回答
我一直在尝试使用模板化的适配器来启用重载操作符。我得到了一个编译错误(gcc 4.5.2)，这对我来说似乎是矛盾的。我想知道为什么以及如何绕过它。下面是说明问题的简化代码。
// The adapter
template <typename T>
class A {
T t;
public:
A(T t_) : t(t_) {}
};
// Utility function to return an adaptor
template <typename T>
A<T> make_A(T t) {
A<T> a(t);
浏览 2提问于2012-05-17得票数 3
回答已采纳
使用流运算符的c++代码失败。我不能弄清楚为什么第二个打印"DEF“不能工作：：
#include <iostream>
#include <sstream>
struct logger :public std::ostringstream {};
struct logger_flush {};
logger_flush endl;
std::ostream& operator << (std::ostream& os, const logger_flush& lf) {
logger& oss = dy
浏览 1提问于2014-02-20得票数 2
3回答
我偶尔会在StackOverflow上看到一些代码，询问一些涉及如下函数的重载歧义：
void foo(int&& param);
我的问题是:为什么会出现这种情况？或者更确切地说，你什么时候会有“对引用的引用”？这与普通的旧引用有什么不同？我从来没有在现实世界的代码中遇到过这种情况，所以我很好奇什么样的代码会需要它。
浏览 0提问于2011-04-08得票数 61
回答已采纳
3回答
我对模板函数和非模板函数之间的c++重载解析感到困惑，以下是示例：
class Stream {};
struct M
{
M(float v) {}
};
template <class T>
Stream& operator<<(Stream& stream, T& v) {}
Stream& operator<<(Stream& stream, const M& v) {}
int main()
{
Stream stream;
int a = 1;
stream
浏览 4提问于2018-08-16得票数 3
5回答
执行此操作时：
int square(int& x) { return x*x;};
int s = square(40); // This gives error
要解决此问题，请执行以下操作：
int square(const int& x) { return x*x;};
int s = square(40); // This is OK
我知道40是一个常量，但如果我这样做：
const int& x = 40
为什么只有const关键字才可以呢？这是编译器保护没有人可以更改x引用的值的方式吗？
40是一个常量，所以我们甚至不知道它在内存中的位置，但是编译
浏览 1提问于2012-11-11得票数 2
回答已采纳
1回答
#include <bits/stdc++.h>
struct Row
{
int a;
Row() { puts("default"); }
Row(const Row &other) { puts("copy"); }
Row(Row &&other) { puts("move"); }
Row(int) { puts("conv. c'tor"); }
};
Row return_row()
{
Row r(6);
Row second = r;
浏览 0提问于2020-12-21得票数 0
我写了以下代码：
#include <iostream>
class A
{
public:
A(){ std::cout << "created" << std::endl; }
A(A& other) { std::cout << "copied" << std::endl; }
A& get(){ std::cout <<"got" << std::endl; return *this; }
~A(){ st
浏览 0提问于2011-10-22得票数 2
回答已采纳
1回答
我有一个返回字符串向量的函数
std::vector<std::string> getNames()
{
std::vector<std::string> names;
names.push_back("one");
return names;
}
我还有另一个类，它的构造函数具有以下签名(这实际上来自TCLAP)：
ValuesConstraint(std::vector<T>& allowed);
如果我尝试执行以下操作，则会收到错误
ValuesConstraint<std::string> A( getNames(
浏览 12提问于2013-07-09得票数 2
回答已采纳
1回答
来自高效现代C++的工作，第25项。我们有一个例子
案例1
class Widget {
public:
template<typename T>
void setName(T&& newName)
{ name = std::forward<T>(newName); }
...
};
案例2
class Widget {
public:
void setName(const std::string& newName)
{ name = newName; }
void setName(std::string&& newName)
浏览 8提问于2018-01-30得票数 4
回答已采纳
1回答
我知道是一个 (“纯”右值)指针，通过将关键字const或volatile附加到它所属的函数定义的末尾，可以使它成为指向常量的指针和/或指向易失性的指针(影响对其实例变量的访问)。
我还知道，this有时(错误地)被描述为一个常量指针，可能是一种说“你不能给this赋值”的方式。作为一个右值，它本质上是不可赋值的，因此不需要const右值的概念。
我也知道在C++11中，有些情况下，右值或左值会影响调用解析，但我已经尝试过这些可能性，我不确定是否存在调用解析的情况，即this是右值指针，而不是const左值指针。
从程序员的角度来看，这种区别有没有真正的不同，比如可以使用右值指针而不能使用co
浏览 1提问于2016-02-10得票数 13
class TestClass
{
public:
TestClass(){
cout<<"constructor"<<endl;
p = {1,2,3};
cout<<(unsigned int *)(this->p.data())<<endl;
}
TestClass(const TestClass& test): p(std::move(test.p))
{
cout <<"copy constructor"&l
浏览 0提问于2017-12-23得票数 3
好的，我有一个唯一的指针，使用unique_ptr::get来获取指针，并把它传递给一个std：：函数，它的参数是int*& b。它似乎返回了一个错误。我只是好奇我做错了什么，以及如何改正。我放了一小段代码，谢谢。
std::function<void(int*& b)> foo;
int main()
{
foo = [&](int*& b) {
b++;
};
std::unique_ptr<int> i = std::make_unique<int>(5);
foo(i.
浏览 10提问于2020-05-13得票数 0
回答已采纳
1回答
我试图创建一个函数来初始化一个结构，并在返回值中将其传递回来，但我无法使其工作。我哪里弄错了？我得到了一个分段错误。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
int id;
char *name;
} Object;
Object object_ctor(int id, char *name);
int main()
{
Object x;
x = object_ctor(1, "Alex")
浏览 0提问于2016-11-28得票数 1
假设我有以下对象
class foo
{
foo() {..} //Constructor
foo(const foo& f) {..} //Copy Constructor - `f` is lvalue reference
foo(foo&& g) {...} //Move constructor
};
现在我知道在声明中
foo(const foo& f) {..}
F是左值引用
现在我的问题是，在声明中
foo(foo&& g) {...}
我知道g是一个右值，但
浏览 1提问于2014-05-12得票数 2
2回答
我对下面的代码有点困惑。`
class sample
{
public:
sample() { }
sample( sample& Obj ) { }
};
void fun( sample& Obj ) { }
int main()
{
sample s(sample());
fun( sample() );
return 0;
}
我得到了下面的错误
由于以下错误，编译失败。sample:在函数'int main()‘中: main.cpp:29:19:错误:从类型为'sample’fun(
浏览 0提问于2018-02-23得票数 4
2回答
下面的代码很好用：
constexpr double square_cstxpr(double x) { return x * x; }
int main() {
const int test = 5;
constexpr double result = square_cstxpr((double)test);
}
但是，如果test的类型从const int更改为const double，g++会显示以下错误：the value of 'test' is not usable in a constant expression。
在这里查看g++的代码和输出：
浏览 0提问于2017-08-09得票数 16
回答已采纳
我不明白以下几点：
class Class {
public:
void operator=(string&&) {
cout << "here";
}
};
string func() {
return "Paul";
}
int main()
{
string&& rvalueref = func();
Class obj;
obj = rvalueref; <- error! Why isn't rvalueref a rvalue re
浏览 2提问于2015-04-24得票数 0
我想有一些关于临时对象的东西我不理解。给定这些关系：
class C {};
class F {
public:
C getC() { return C(); };
};
class N {
public:
N( C & base ){};
};
这是可行的：
N n(C());
这不起作用：
F f;
N n(f.getC()); //compile error
为什么？
浏览 0提问于2012-06-12得票数 0
回答已采纳
下面的C++11程序是不是格式错误？
const int x[] = {1,2,3};
static_assert(x[0] == 1, "yay");
int main() {}
gcc和clang似乎是这么认为的，但是为什么x[0] == 1不是一个恒定的表达呢？
x[0] == 1
subscript operator
*(x+0) == 1
array-to-pointer conversion (int* p = x)
*(p+0) == 1
pointer addition
*p == 1
indirection (lvalue y = x[0])
y == 1
浏览 34提问于2013-09-20得票数 19
在下面的代码片段中std::move是必需的吗？
std::function<void(int)> my_std_function;
void call(std::function<void(int)>&& other_function)
{
my_std_function.swap(std::move(other_function));
}
据我所知，call()接受右值引用..但是由于右值引用本身是一个左值，为了调用swap(std::function<void(int)>&&)，我必须用std::move将其重新转
浏览 1提问于2016-01-04得票数 13
2回答
最近，我在阅读时遇到了这样的问题：
T const& operator *() const& ;
T& operator *() & ;
T&& operator *() && ;
我还编写了自己的程序，将成员函数定义为const&、&和&& (请注意，我说的不是返回类型，而是分号前面的说明符)，它们似乎工作得很好。
我知道声明一个成员函数const意味着什么，但是谁能解释一下声明它const&，&&和&&意味着什么？
浏览 6提问于2015-01-21得票数 69
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
