标签: assignment-operator

在我看来，派生类不继承基类赋值运算符，
如果派生类继承基类赋值运算符，请解释以下示例

在下面的代码中，我覆盖了派生类中的基类 operator=，以便派生类默认赋值运算符调用重载的 operator=

#include <iostream>  
using namespace std;      
class Base  
{  
    public:  
    Base(int lx = 0):x(lx)  
    {  
    }  

    virtual Base& operator=( const Base &rhs)  
    {  
        cout << "calling Assignment operator in Base" << endl;  
        return *this;  
    }

    private:  
    int x;     
};      


class Derived : public Base  
{  
    public:  
    Derived(int lx, int ly): Base(lx),y(ly)  
    {  
    }

    Base& operator=(const Base &rhs)  
    {  
        cout << "Assignment operator in Derived"<< endl;  
        return *this;  
    }  

    private:  
    int y;    
};  



int main()  
{  
    Derived …

所以我在 quora 文章中遇到了这段代码来交换两个数字。

a = a + b - (b = a);

我试过了，效果很好。但是既然b = a是在括号中，不应该首先为 b 值分配 a 的值吗？整个事情应该成为a + a - a 一个保留其价值的东西？

我试过a = b + (b = a);了a = 5 b = 10，最后我得到了一个 = 10。看到这里我猜它被评估为a = a + a

为什么会出现这种异常？

我std::map想在其中插入一个对象，但我想避免不必要的复制，因为它是一个大对象，并且复制需要时间。我试过这个：

MyPODType data(otherData);
data.modify();
myMap["Some key"] = data;

然而，这需要 2 个副本：一份用于复制otherData，一份在赋值运算符中用于插入对象。由于是POD，复制构造函数和赋值运算符都是默认的。

我怎样才能只用一份副本来做到这一点？我意识到一些编译器会优化第二个副本，但我想以可移植的方式做到这一点。

我刚刚在《C++ Primer （第五版）》第 563 页上了解到，可以重载赋值运算符。因此，如果我正在编写一个类C，并且将整数分配给此类的对象是有意义的，那么我可以提供一个rhsof 类型的赋值运算符int。然后我班的客户可以写：

C c;
...
c = 5;

问题：如果这样的赋值有意义，那么隐式构造函数C(int);也应该有意义吗？如果是这样，那么我应该真正定义这个构造函数（它也有其他用途）并且永远不需要重载赋值运算符。我错过了什么吗？

为了更具体的 std::is_assignable_v<int, int> << '\n'; 回报false？是因为int没有重载赋值运算符(原始类型和所有)？

(顺便std::is_trivially_assignable_v<int, int>给false过.)

请注意:这 struct Structure {}; std::is_assignable<class Structure, class Structure>::value; 将返回true,因为隐式定义了重载的赋值运算符Structure.

到目前为止我是否正确？如果是这样,那么我认为增强is_assignable接受原始类型也不是一件容易的事吗？否则,任何有关这种可能的解决办法的提示？

我必须表达：

%MON =    months => 1, end_of_month => 'limit';      # months => undef
%MON =  ( months => 1, end_of_month => 'limit' );

为什么第一个表达式只产生一个months带undef值的键？它们之间有什么区别？

像这样组合声明和赋值是很常见的：

int beans = a * 2;

或分开，像这样

int beans;
beans = a * 2;

我目前的理解是bean可以被赋值，因为它是左值；它具有可写入的存储空间。右值a * 2无法分配给它，因为它只是一个带有值的表达式，没有存储空间。因此，这是允许的：

int beans;
(beans) = a * 2;

事实上，任何作为左值的左操作数都应该有效。现在，这似乎表明int beans;是一个表达式，也是一个左值。但是，这是不允许的：

(int beans) = a * 2;

就 C 解析器的设计方式而言，这表明声明不仅仅是带有左值的表达式。这里发生了什么？

救命

#include <iostream>
#include <math.h>
using namespace std;
const float pi = 3.14;
void Odabir(int);
int main(){
    int choose;
    cout << "Odaberite 1 2 ili 3" << endl;
    cin >> choose;
    Odabir(choose);
    return 0;
}
void Odabir(int choose){
    if (choose = 1){
        float b, vb;
        cout << "Unesite duljinu stranice b: " << endl;
        cin >> b;
        cout << "Unesite duljinu visine na stranicu b vb: " << endl;
        cin >> vb;
        cout << "Povrsina raznostranicnog trokuta je: " << …

任何人都可以告诉输出如何变成undefined？

var foo = {n: 2};
foo.x = foo = {n: 2};
console.log(foo.x); // undefined

出于好奇,为什么按位运算符~是唯一一个在C++中没有赋值版本的非逻辑运算符,即~=？所有关系运算符和按位运算符都有赋值版本,但~=缺少.这有什么特别的原因吗？

对于C++中的所有运算符,请参阅:http://www.tutorialspoint.com/cplusplus/cpp_operators.htm