标签: assignment-operator

我想知道为什么我需要在这种情况下声明一个默认构造函数.首先,如果我把它遗漏,编译器是否会自动执行此操作？无论如何,我仍然不明白为什么它是必要的.此外,即使我省略'obj_B = origin.obj_B;',我也会收到错误.

class B
{
public:
    bool theArray[5] ;

    B(bool x) {theArray[1] = x;};
    //B(){};    
};

class A
{
public:
    B obj_B;

    A() : obj_B(1) {};
    A(A const &origin) {obj_B = origin.obj_B;}; //error:no matching function for call 
                                                      //to B::B()
}; 

int main () 
{
    std::vector <A> someAs;
    for(int q=0;q<10;q++)
        someAs.push_back(A());

    for(int q=0;q<10;q++)
        std::cout << someAs[q].obj_B.theArray[1] << std::endl;
}

我想让以下代码工作:

Mylist lst;
vector<int> v = lst;

所以我看到我需要将列表转换为矢量.我试过这段代码:

vector<int> operator=(vector<int> v, const List & l) {
    return v; // more profound stuff later :-)
}

(把它放在课外).不幸的是Visual Studio抛出了我:"错误:'operator ='必须是成员函数".我不明白 - 我该怎么办？我不能把这个功能放在矢量类中......你可以帮帮我吗？谢谢!

假设我有:

class A {
public:
    const int x;
    A() : x(3) {}
}

我想创造

std::vector<A>

g ++抱怨默认赋值运算符在尝试执行时不起作用this->x = x,因为xconst是无法完成的.有没有办法解决？

我正在实施一个链表.我写了一个拷贝构造函数:

        // --- copy constructor ---
    IntList(const IntList& last_list) {
        first = new IntNode(last_list.getFirst()->getData());
        cout << "copy first " << first->getData() << endl;

        IntNode* last_node = first;
        IntNode* node = last_list.getFirst()->getNext();
        while(node!=NULL) {
            IntNode* new_node = new IntNode(node->getData());
            last_node->setNext(new_node);
            cout << "copy " << new_node->getData()<< endl;
            last_node = new_node;
            node = node->getNext();
        }
    }

据我了解,我的副本赋值运算符(operator=)应该有2个目标:

• 删除当前列表.
• 复制新列表.

我可以通过调用我已编写的析构函数来实现这两个目标,然后调用复制构造函数.我该怎么做？

考虑以下代码:

class vector{
   // ...
   vector(int size){ /*...*/ };
   vector& operator= (const vector& other){
   // ...
   }
};

int main(){
   vector v1(5), v2(10);
   v1 = v2;
}

我operator =应该在这做什么？v1没有足够的容量存储元素v2.从我的角度来看,它可以将自身重新初始化为10的容量,并复制其他向量的元素或抛出异常.我通常选择前一种方法,但越来越多地经常看到后者.哪一个是正确的？

我有这个例子:一个矩阵的类,矩阵的维度作为模板参数给出.

template <std::size_t DIM>
class Matrix {
   // ...
};

int main()
{
  Matrix<2> m2;
  Matrix<4> m4;

  m2 = m4;
}

笏做我的赋值操作符都看起来像的改变DIM的m22至4？

非常直截了当的问题:

要求赋值运算符不能抛出异常的原因是什么？

同时,构造函数可以抛出？

如果你不能抛出异常,如果没有足够的内存用于缓冲区分配,如何处理众所周知的"自定义"字符串示例？

如果你只是分配更少或保持旧状态,但不抛出异常,一切都会"看起来"平滑,但会出现严重(隐藏)错误.

我试过这样做但是出错了.为什么我不能这样做？

int main()
{
char sweet[5];
sweet = "kova";
printf("My favorite sweet is %s\n", sweet);

return 0;
}

我想超载operator=(),但我得到了error: no viable overloaded '='.但我不明白为什么.我在这里错过了什么？我厌倦了在可以转换为另一个模板类型的类模板中的重载赋值运算符中的答案,但是有人说要给返回类型的模板参数一个新类型......？这导致编译器抱怨我的类型不明.

template<typename T, typename P>
class SomeClass
{

public:

    SomeClass<T, P> operator=(SomeClass<T, P>& src)
    {
        if (this != &src)
        {
            vectorfield.resize(src.vectorfield.size());
            for (int i = 0; i < src.vectorfield.size(); ++i)
            {
                vectorfield[i] = src.vectorfield[i];
            }
        }
        return *this;
    }

private:

    std::vector<std::vector<std::string>> vectorfield;
};



template<typename SC>
class SomeOtherClass
{

public:

    typedef SC someclass_type;

    void func()
    {
       sc = someclass_type();
    }

private:
    someclass_type sc;
};


int main()
{

    typedef SomeClass<int, …

我正在尝试使用window.requestAnimationFrame（）时跟踪时间，但即使我要增加的值不是NaN，+ =运算符也会继续返回NaN

var elapsedTime = 0
var lastTime = 0
var between = 500
var count = 0
var betweenCount = 0
function frame(time) {
    elapsedTime = time - lastTime
    console.log(elapsedTime)
    lastTime = time
    betweenCount += elapsedTime
    console.log(betweenCount)
    window.requestAnimationFrame(frame)
}

frame()

betweenCount应该跟踪自上次重置以来的总经过时间，但是一旦为其指定了lapsedTime，它就变为NaN，但是此时的经过时间不是NaN。