c++ 源码中&&变量是什么意思呢？

[芥末的无奈]

源码中经常见到类似 _Valty&& _Val 这样的参数，这种变量是什么意思？

[iihero_]

并且的意思。　逻辑与

[taodm]

C++2011标准的 右值引用 语法，没听说的需要去补课啦，要与时俱进啦。

[芥末的无奈]

引用 7 楼 taodm 的回复:

C++2011标准的 右值引用 语法，没听说的需要去补课啦，要与时俱进啦。

原来叫这个啊，完全没听说啊。去补课了。

[xyzinfernity]

去搜索“c++11右值引用”

[熊熊大叔]

&& 就是其他语言里的and

[lm_whales]

引用 7 楼 taodm 的回复:

C++2011标准的 右值引用 语法，没听说的需要去补课啦，要与时俱进啦。

++

[lpcads]

右值引用。 举个例子

//需要一次构造，两次赋值，即三次深拷贝
swap(T &a,T &b)
{
	T tmp(a);
	a = b;
	b = tmp;
}

使用右值引用后只需三次浅拷贝就能圆满完成任务。

[xu6148152]

确实是右值引用，C++11的新特性。

[翅膀又硬了]

引用 7 楼 taodm 的回复:

C++2011标准的 右值引用 语法，没听说的需要去补课啦，要与时俱进啦。

与时俱进

[滴答滴答D]

引用 15 楼 qq120848369 的回复:

右值引用，当传入临时对象时可以避免一次拷贝。

不是这样的吧，这是一个重载函数：

    _Myt& operator=(const _Valty& _Val)  
        {   // insert into container and increment stored iterator  
        iter = container->insert(iter, _Val);  
        ++iter;  
        return (*this);  
        }  
  
    _Myt& operator=(_Valty&& _Val)  
        {   // push value into container  
        iter = container->insert(iter, _STD forward<_Valty>(_Val));  
        ++iter;  
        return (*this);  
        }  
  

只用传递常量值时才会调用右值引用的方法，临时变量应该是调用第一种方法吧

[unituniverse2]

引用 21 楼 It_way 的回复:

[quote=引用 15 楼 qq120848369 的回复:] 右值引用，当传入临时对象时可以避免一次拷贝。

不是这样的吧，这是一个重载函数：

    _Myt& operator=(const _Valty& _Val)  
        {   // insert into container and increment stored iterator  
        iter = container->insert(iter, _Val);  
        ++iter;  
        return (*this);  
        }  
  
    _Myt& operator=(_Valty&& _Val)  
        {   // push value into container  
        iter = container->insert(iter, _STD forward<_Valty>(_Val));  
        ++iter;  
        return (*this);  
        }  
  

只用传递常量值时才会调用右值引用的方法，临时变量应该是调用第一种方法吧 [/quote] 临时变量就是调用第二种的（所以才叫右值）。C++11中右值的定义就是非具名（指的是变量名，不是类型名）临时变量

[unituniverse2]

class A {}; void foo(const A &) {}; // 函数1 void foo(A &&) {}; // 函数2 ... A a; const A ac; foo(ac);// 函数1将被调用 foo(a);// 函数1将被调用 foo(A());// 函数2将被调用 foo(std::move(a));// 函数2将被调用

[unituniverse2]

引用 18 楼 lpcads 的回复:

右值引用。 举个例子

//需要一次构造，两次赋值，即三次深拷贝
swap(T &a,T &b)
{
	T tmp(a);
	a = b;
	b = tmp;
}

使用右值引用后只需三次浅拷贝就能圆满完成任务。

这个例子调用的仍然是拷贝，因为a、b和tmp均为具名的变量，按右值定义，这种情况a、b和tmp都是左值。 要使用右值版本的拷贝构造和赋值话（即移动构造和移动赋值），应改成下面的样子：

swap(T & a,T & b)
{
	T tmp(std::move<T>(a));
	a = std::move<T>(b);
	b = std::move<T>(tmp);
}

[赵4老师]

//C++ Operators
//  Operators specify an evaluation to be performed on one of the following:
//    One operand (unary operator)
//    Two operands (binary operator)
//    Three operands (ternary operator)
//  The C++ language includes all C operators and adds several new operators.
//  Table 1.1 lists the operators available in Microsoft C++.
//  Operators follow a strict precedence which defines the evaluation order of
//expressions containing these operators.  Operators associate with either the
//expression on their left or the expression on their right;    this is called
//“associativity.” Operators in the same group have equal precedence and are
//evaluated left to right in an expression unless explicitly forced by a pair of
//parentheses, ( ).
//  Table 1.1 shows the precedence and associativity of C++ operators
//  (from highest to lowest precedence).
//
//Table 1.1   C++ Operator Precedence and Associativity
// The highest precedence level is at the top of the table.
//+------------------+-----------------------------------------+---------------+
//| Operator         | Name or Meaning                         | Associativity |
//+------------------+-----------------------------------------+---------------+
//| ::               | Scope resolution                        | None          |
//| ::               | Global                                  | None          |
//| [ ]              | Array subscript                         | Left to right |
//| ( )              | Function call                           | Left to right |
//| ( )              | Conversion                              | None          |
//| .                | Member selection (object)               | Left to right |
//| ->               | Member selection (pointer)              | Left to right |
//| ++               | Postfix increment                       | None          |
//| --               | Postfix decrement                       | None          |
//| new              | Allocate object                         | None          |
//| delete           | Deallocate object                       | None          |
//| delete[ ]        | Deallocate object                       | None          |
//| ++               | Prefix increment                        | None          |
//| --               | Prefix decrement                        | None          |
//| *                | Dereference                             | None          |
//| &                | Address-of                              | None          |
//| +                | Unary plus                              | None          |
//| -                | Arithmetic negation (unary)             | None          |
//| !                | Logical NOT                             | None          |
//| ~                | Bitwise complement                      | None          |
//| sizeof           | Size of object                          | None          |
//| sizeof ( )       | Size of type                            | None          |
//| typeid( )        | type name                               | None          |
//| (type)           | Type cast (conversion)                  | Right to left |
//| const_cast       | Type cast (conversion)                  | None          |
//| dynamic_cast     | Type cast (conversion)                  | None          |
//| reinterpret_cast | Type cast (conversion)                  | None          |
//| static_cast      | Type cast (conversion)                  | None          |
//| .*               | Apply pointer to class member (objects) | Left to right |
//| ->*              | Dereference pointer to class member     | Left to right |
//| *                | Multiplication                          | Left to right |
//| /                | Division                                | Left to right |
//| %                | Remainder (modulus)                     | Left to right |
//| +                | Addition                                | Left to right |
//| -                | Subtraction                             | Left to right |
//| <<               | Left shift                              | Left to right |
//| >>               | Right shift                             | Left to right |
//| <                | Less than                               | Left to right |
//| >                | Greater than                            | Left to right |
//| <=               | Less than or equal to                   | Left to right |
//| >=               | Greater than or equal to                | Left to right |
//| ==               | Equality                                | Left to right |
//| !=               | Inequality                              | Left to right |
//| &                | Bitwise AND                             | Left to right |
//| ^                | Bitwise exclusive OR                    | Left to right |
//| |                | Bitwise OR                              | Left to right |
//| &&               | Logical AND                             | Left to right |
//| ||               | Logical OR                              | Left to right |
//| e1?e2:e3         | Conditional                             | Right to left |
//| =                | Assignment                              | Right to left |
//| *=               | Multiplication assignment               | Right to left |
//| /=               | Division assignment                     | Right to left |
//| %=               | Modulus assignment                      | Right to left |
//| +=               | Addition assignment                     | Right to left |
//| -=               | Subtraction assignment                  | Right to left |
//| <<=              | Left-shift assignment                   | Right to left |
//| >>=              | Right-shift assignment                  | Right to left |
//| &=               | Bitwise AND assignment                  | Right to left |
//| |=               | Bitwise inclusive OR assignment         | Right to left |
//| ^=               | Bitwise exclusive OR assignment         | Right to left |
//| ,                | Comma                                   | Left to right |
//+------------------+-----------------------------------------+---------------+

[shiguojie19892]

引用 6 楼 iihero 的回复:

并且的意思。　逻辑与

对的

[jiandingzhe]

引用 13 楼 shiguojie19892 的回复:

[quote=引用 6 楼 iihero 的回复:] 并且的意思。　逻辑与

对的[/quote] 对个毛！！参数声明怎么个逻辑与。

[qq120848369]

右值引用，当传入临时对象时可以避免一次拷贝。

[赵4老师]

引用 15 楼 qq120848369 的回复:

右值引用，当传入临时对象时可以避免一次拷贝。

学习了……

[mujiok2003]

rvalue reference

[shiguojie19892]

引用 18 楼 lpcads 的回复:

右值引用。 举个例子

//需要一次构造，两次赋值，即三次深拷贝
swap(T &a,T &b)
{
	T tmp(a);
	a = b;
	b = tmp;
}

使用右值引用后只需三次浅拷贝就能圆满完成任务。

请给写一下右值引用在此的用法。