标签: operator-overloading

我已经开始学习C++了,所以我不知道在缺乏知识/经验的情况下为什么对于新手来说看似简单的东西,因为我将要描述的内容尚未出现在STL中.要将矢量添加到另一个矢量,您必须输入以下内容:

v1.insert(v1.end(), v2.begin(), v2.end());

我想知道在现实世界中人们是否只是重载+ =运算符以使其更简洁,例如对于

template <typename T>
void operator+=(std::vector<T> &v1, const std::vector<T> &v2) {
    v1.insert(v1.end(), v2.begin(), v2.end());
}

那么你可以

v1 += v2;

我也把这个设置为push_back到"+ ="一个元素到最后.是否有某些原因这些事情不应该由熟练使用C++的人完成或特别避免？

在我正在进行的项目中,我有一个Score类,定义如下score.h.我试图超载它,因此,当对其<<执行操作时,_points + " " + _name打印.

这是我试图做的事情:

ostream & Score::operator<< (ostream & os, Score right)
{
    os << right.getPoints() << " " << right.scoreGetName();
    return os;
}

以下是返回的错误:

score.h(30) : error C2804: binary 'operator <<' has too many parameters

(此错误实际出现4次)

我设法通过将重载声明为友元函数来使其工作:

friend ostream & operator<< (ostream & os, Score right);

并Score::从score.cpp中删除函数声明(实际上没有将其声明为成员).

为什么这样做,但前一段代码没有？

谢谢你的时间!

编辑

我删除了头文件上的重载的所有提及...但我得到以下(和唯一)错误.binary '<<' : no operator found which takes a right-hand operand of type 'Score' (or …

C++中有4个运算符可以重载但不能作为独立(即非成员,独立)函数重载.这些运营商是:

• operator =
• operator ()
• operator ->
• operator []

这个主题完全解释了禁止operator =成为非成员函数的理由.关于其他三个的任何想法？

在我的小项目中,我正在使用System.Reflection类来生成可执行代码.我需要调用+自定义类型的运算符.有谁知道如何使用C#反射调用自定义类的自定义运算符？

我为我的模板类写了一个运算符<<

template<class T>
std::ostream& operator<<(std::ostream &strm, const MyClass<T> &obj)

当我写作

cout << myClassInstance << endl;

这编译并运行,但我的Eclipse CDT说:

'endl'的重载无效

为什么告诉我这个？

(我在Win7 64bit上使用Eclipse CDT Kepler和Cygwin gcc)

我最近开始自学游戏编程.有人建议我从Python开始,我得到了"用Python和Pygame开始游戏开发:从新手到专业"的书.我得到了一个他们教导Vector和创建Vector2类的部分.一切顺利,直到我试图超过除法运算符.我的代码是这样的:

class Vector2(object):

  def __init__(self, x=0.0, y=0.0):
    self.x = x
    self.y = y

  def __str__(self):
    return "(%s, %s)"%(self.x, self.y)

  @classmethod
  def from_points(cls, P1, P2):
    return cls(P2[0] - P1[0], P2[1] - P1[1])

  def __add__(self,rhs):
    return Vector2(self.x + rhs.x, self.y + rhs.y)

  def __sub__(self,rhs):
    return Vector2(self.x - rhs.x, self.y - rhs.y)

  def __mul__(self, scalar):
    return Vector2( self.x*scalar, self.y*scalar)

  def __div__(self, scalar):
    return Vector2( self.x/scalar, self.y/scalar)

现在,当我尝试调用"/"运算符时,会显示:

AB = Vector2(10.0,25.0)
print(AB)   # <<<<(10.0, 25.0)
v1 = AB + Vector2(20.,10.)
print(v1)   # <<<<(30.0, 35.0) …

C++中的运算符通常被认为是函数/方法的替代语法,尤其是在重载的上下文中.如果是这样,下面的两个表达式应该是同义词:

std::cout << 42;
operator<<(std::cout, 42);

实际上,第二个语句会导致以下错误:

call of overloaded ‘operator<<(std::ostream&, int)’ is ambiguous

像往常一样,这样的错误信息附有可能的候选人名单,这些是:

operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
operator<<(basic_ostream<char, _Traits>& __out, char __c)
operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)

这种错误至少引发了两个问题:

1. 这两个语句以什么方式不同(在名称查找方面)？
2. 为什么失踪？operator<<(basic_ostream<char, _Traits>& __out,int__c)

看起来,中缀和前缀符号不是完全可互换的 - 不同的语法需要不同的名称解析策略.有什么区别,它们来自哪里？

这是一个早期问题operator+的后续问题,关于为什么我不能使用大括号括起初始化器作为参数,这是通过查看前面关于该主题的问题来解决的.

考虑以下C++代码,您可以在ideone.com上试用:

#include <iostream>
#include <initializer_list>
using namespace std;

struct AddInitializerList {
    void operator+= (initializer_list<int> values) {
        // Do nothing   
    }

    void operator+ (initializer_list<int> values) {
        // Do nothing
    }
};

int main() {
    AddInitializerList adder;
    adder += {1, 2, 3};  // Totally legit
    adder +  {1, 2, 3};  // Not okay!

    return 0;
}

在该生产线main使用operator+了括号内的初始化列表不编译(和,问这个问题前面经过,我现在知道这是为什么).但是,我很困惑为什么使用opeartor+=in 的代码main确实编译得很好.

我很困惑,为什么我可以重载+=并让它工作得很好,而重载+似乎在这里不起作用.标准中是否有特定的规定允许在+= …

我知道所有关于指针和&符号的意思是"地址",但在这种情况下它意味着什么？

另外,当重载运算符时,为什么通常用const声明参数？

我有一个类型为std :: string的类.我想通过比较属性为类提供一些比较运算符函数,如<,>,==,<=和> =.

我的问题是:任何简单的方法或工具

(1)只写一个或两个函数,例如一个用于运算符<(和==),其他函数可以自动生成.

(2)甚至更简单,因为类比较取决于std::string其比较函数已经提供的类型属性.