标签: assignment-operator

为什么我可以+=在字符串上使用,但我不能使用-=它？

例如...

var test = "Test";
var arr = "⇔"

test += arr;
alert(test);  // Shows "Test⇔"

test -= arr;
alert(test);  // Shows "NaN"

根据对这个帖子的回复,operator=不能作为非成员函数重载.因此,例如,以下内容使编译器非常生气:

class MyClass
{
    // ...
};

MyClass& operator=(MyClass& Left, MyClass& Right)
{
    // ...
}

为什么是这样？我有一个带getter和setter的容器类,因此不需要成员函数,它会破坏封装.上述线程的答案之一是说确保"L值被接收为其第一个操作数",但我不完全理解这意味着什么.有人可以澄清一下吗？

此外,有operator=,operator(),operator[]和operator->"古怪"的情况下......？或者我应该将所有重载的运算符实现为成员函数......？(我知道不这样做是完全合法的,但我正在寻找更好的做法.)

我正在研究数据结构(列表,堆栈,队列),这部分代码让我感到困惑.

ListNode( const Object& theElement = Object(), ListNode * node = NULL);


template<class Object>
ListNode<Object>::ListNode( const Object& theElement, ListNode<Object> * node) {
    element = theElement;
    next = node;
}

1. 为什么函数参数中有赋值运算符？
2. 什么Object()电话呢？

请考虑以下代码:

struct s
{
    const int id;

    s(int _id):
        id(_id)
    {}
};
// ...
vector<s> v;  v.push_back(s(1));

我得到一个编译器错误,'const int id'不能使用默认赋值运算符.

Q1.为什么push_back()需要赋值运算符？
A1.因为目前的c ++标准是这样说的.

Q2.我该怎么办？

A2.我会使用智能指针.

Q3.我提出了一个"解决方案",这似乎相当疯狂:

s& operator =(const s& m)
{
    if(this == &m) return *this;
    this->~s();
    return *new(this) s(m);
}

我应该避免这种情况,为什么(如果是这样)？如果对象在堆栈上,使用placement new是否安全？

以下代码在gcc 4.8.1上编译没有问题:

#include <utility>

struct foo
{
};

int main()
{
    foo bar;

    foo() = bar;
    foo() = std::move( bar );
}

似乎隐式生成的赋值运算符foo不是&ref-qualified,因此可以在rvalues上调用.根据标准,这是正确的吗？如果是这样,有什么理由不要求隐式生成的赋值运算符被重新&限定？

为什么标准不要求生成以下内容？

struct foo
{
  foo & operator=( foo const & ) &;

  foo & operator=( foo && ) &;
};

我发现自己做的一件常见的事情是制作"几乎默认"的复制构造函数和赋值运算符.也就是说,我发现自己处于编译器提供的复制和赋值运算符适用于大多数数据成员的情况,但是有一个特定的数据成员需要以不同的方式处理.这意味着我必须显式创建一个复制构造函数/赋值运算符,包括显式列出具有简单复制语义的所有数据成员.对于存在大量数据成员的类,或者稍后添加成员变量但未添加到复制构造函数/赋值运算符的类时,这会很烦人.

有没有办法告诉C++编译器显式声明的复制构造函数/赋值运算符应该像隐式运算符一样工作,除了之后运行的一些额外代码？(并且这样的语法与C++ 98兼容,还是需要C++ 11或C++ 14支持？)

说我想覆盖operator =所以我可以做类似的事情

Poly p1;  // an object representing a polynomial
Poly p2;  // another object of the same type    
p2 = p1;  // assigns all the contents of p1 to p2

然后在我的实现中operator =,我有这样的事情:

Poly& Poly::operator=(const Poly &source) {
    // Skipping implementation, it already works fine…
    return *this;
}

不介意实现,它已经正常工作.

我关心的是你什么时候会发生什么return *this？我知道它返回对象的引用,但这是怎么回事？

p2 = &p1

所以我有一个提供字符串类型的现有库.

它隐式转换为C样式字符串,如下所示:

struct TypeIDoNotOwn {
  TypeIDoNotOwn() {}
  TypeIDoNotOwn(TypeIDoNotOwn const&) {}
  TypeIDoNotOwn(char const*) {}

  TypeIDoNotOwn& operator=(TypeIDoNotOwn const&) {return *this;}
  TypeIDoNotOwn& operator=(char const*) {return *this;}

  operator char const*() const {return nullptr;}
};

它有其他方法,但我不认为它们很重要.这些方法有机构,但我的问题不涉及它们,所以我把它们剔除了.

我想要做的是创建一个可以与上述类型相对可互换使用的新类型,并使用"raw string constants".我希望能够获取一个实例TypeIDoNotOwn,并替换它TypeIDoOwn,并编译代码.

举个例子,这套操作:

void test( TypeIDoNotOwn const& x ) {}

int main() {
  TypeIOwn a = TypeIDoNotOwn();
  TypeIDoNotOwn b;
  a = b;
  b = a;
  TypeIOwn c = "hello";
  TypeIDoNotOwn d = c;
  a = "world";
  d = "world";
  char const* e …

为什么这种未定义的行为？

struct s
{
    const int id; // <-- const member

    s(int id):
        id(id)
    {}

    s& operator =(const s& m) {
        return *new(this) s(m); // <-- undefined behavior?
    }
};

(从标准引用会很好).

这个问题来自于这个答案.

我知道列表赋值会使其左侧变平：

my ($a, $b, $c);\n($a, ($b, $c)) = (0, (1.0, 1.1), 2);\nsay "\\$a: $a"; # OUTPUT: \xc2\xab$a: 0\xc2\xbb\nsay "\\$b: $b"; # OUTPUT: \xc2\xab$b: 1 1.1\xc2\xbb    <-- $b is *not* 1\nsay "\\$c: $c"; # OUTPUT: \xc2\xab$c: 2\xc2\xbb        <-- $c is *not* 1.1\n

我也明白我们可以用来:($a, ($b, $c)) := (0, (1.0, 1.1))获得非扁平化行为。

我不明白的是为什么在列表分配期间左侧被展平。这是两个问题：首先，这种扁平化行为如何与语言的其余部分相适应？其次，自动展平是否允许任何在左侧不展平时不可能出现的行为？

关于第一个问题，我知道 Raku 历史上有很多自动扁平化行为。在Great List Refactor之前，像这样的表达式my @a = 1, (2, 3), 4会自动展平其右侧，从而产生 Array [1, 2, 3, 4]；同样，map许多其他迭代结构也会使他们的论点变得扁平化。不过，在 …