标签: assignment-operator

我现在正在学习 Ruby 中的并行赋值运算符。当我尝试使用它来交换数组中的值时，我得到了意想不到的结果。在网上找不到这个问题的答案，希望有人能够阐明这里发生的事情。

第一个例子：

array = [1,2,3]
=> [1, 2, 3]
array[0,1] = array[1,0] 
=> []
array
=> [2, 3] #thought this would be = [2,1,3]

array[0] 去了哪里？为什么 Ruby 不交换这些值？

第二个例子：

array = [1,2,3]
=> [1, 2, 3]
array[0,1] = [1,0]
=> [1, 0]
array
=> [1, 0, 2, 3] #was expecting [1,0,3]

为什么 Ruby 将右侧插入数组而不替换值？

当然，返回类型会有所不同，但概念是相同的：将数据从一个对象复制到另一个对象，对吧？

我一直在尝试使用 C++ 类创建代码接口。

测试中出现的一个令人困惑的事情是重载赋值运算符。看看下面的代码：

struct my_object {
  // This doesn't work. :(
  friend int& operator =(int& variable, my_object object)
  { variable = object.value; return variable; }

  // This works, but `int value; value <<= my_object{};` 
  // for `int value; value = my_object{};` doesn't seem clean...
  friend int& operator <<=(int& variable, my_object object)
  { variable = object.value; return variable; }
};

我的困惑是：
第一个重载不会编译并将此错误记录到控制台终端。

'friend int& operator =(int&, my_object)' must be a nonstatic member function

但是，第二个重载编译时没有任何错误（或警告），尽管与第一个重载几乎相同。

为什么第一个运算符重载无效而第二个运算符重载似乎很好（至少对于GCC 6.3.0编译器来说）？

这段代码有什么问题？我不明白为什么这不起作用。

struct point {
    int x;
    int y;
} eh;

void main() {
    eh = {1, 2};
    printf("%i", eh.x);
}

但这很好用

struct point {
    int x;
    int y;
} eh;

void main() {
    eh.x = 2;
    printf("%i", eh.x);
}

有没有一种方法可以在不创建实用程序的情况下“分配和返回”？这是我的代码：

static int& do_work_(const int* p, int& result)
{
   result = (*p) * 10;
   return result;
}

template<typename T>
T& assign(const T* p, T& result)
{
   result = *p;
   return result;
}

int& do_work(const int* p, bool cond, int& result)
{
   return cond ? do_work_(p, result) : assign(p, result);
}

我可以do_work()在没有该assign()实用程序的情况下实施吗？

签名的原因do_work()是它很方便：

const int value=1;
int i, j;
if (do_work(&value, true, i) == do_work(&value, false, j)) {}

当我在寻找表达式v[i++]=i;为什么是定义行为的时候，突然看到了一个解释，因为表达式存在于程序中的两个序列点之间，而c标准规定了在两个序列点中边的出现顺序效果是不确定的，所以程序中运行表达式时，不确定是++先操作运算符还是先操作=运算符。我对此感到困惑。当表达式求值的过程中，不应该先用优先级来判断，然后引入顺序点来判断先执行哪个子表达式吗？我错过了什么吗？

当俄罗斯用户AnT站 这样解释时，是否意味着在程序中编写诸如a[i]=y++;或 之类的代码a[i++]=y;无法确定++操作员和=操作员无法确定谁先运行。

当我编写一个演示字符串类时，在复制赋值函数中，我尝试在复制之前通过“删除此”来清除自身。但它失败了。

    Str &operator=(const Str &s) {
        if (this != &s) {  // self-assignment check
            //delete this; //cannot run as I imagine
            this->~Str();  
            _size = s._size;
            _str = new char[_size + 1];
            memcpy(_str, s._str, _size + 1);
        }
        return *this;
    }
    ~Str() {
        _size = 0;
        delete[] _str;
    }

linux 告诉我的

双释放或损坏（出）中止（核心转储）

我正在学习Java，我有一个关于赋值操作的返回值的属性的问题。我知道 Java 在 中 赋值之后返回变量的值x = y，但是这个赋值何时发生：在涉及赋值的整个表达式之前还是之后？它是在Java中定义的，是否在表达式中a == (a = b)，变量的值在比较结果之前被true修改，或者如果表达式给出了一个相当于的值a == b，a然后 赋值b？

我知道那a == (a++)是truewhile 的a = (++a)结果false- 这里它确实稍后执行一元增量，即使存在括号。

int a = 2;
System.out.println(a == (a = 2*a+1));
System.out.println(a);

这确实产生了

false
5

作为输出，类似于一元增量的行为。我的编译器就是这样，还是这种行为实际上是通过=操作定义的？

我编写了一个代码,用于动态分配名称.我知道我应该在这种情况下处理深层复制.我写的是我自己的Copy Constructor,Copy Assignment Operator和析构函数.我应该重新定义任何其他隐式函数,例如移动赋值运算符.我不清楚Move Assignment Operator的概念或任何其他隐式定义的成员函数(除了我已经提到的).任何人都可以为此添加代码dynName code,以显示移动赋值运算符或任何其他隐式成员函数(如果有).

#include <iostream>

using namespace std;

class dynName{
    char* name;
    int size;
    public:

    dynName(char* name="")
    {
        int n=strlen(name)+1;
        this->name= new char[n];
        strncpy(this->name,name,n);
        size=n;
        name[size-1]='\0';//NULL terminated
        cout << "Object created (Constructor) with name : "
        << name << " at address " << &(this->name) << endl;
        }

    dynName(const dynName& Ob)//Copy Constructor
    {
        int n=Ob.size;
        this->name= new char[n];
        strncpy(this->name,Ob.name,n);
        size=n;
        cout << "Object created(Copy constructor) with name : "
        << this->name  << " …

如果我的类上有一个运算符重载,那么是否也隐式创建了运算符的赋值版本？

class square{
   square operator+(const square& B);
   void operator=(const square& B);
};

在那里,我可以打电话

square A, B;
A += B;

编译器隐式决定调用'operator +'然后'operator ='？