标签: operator-keyword

什么是最优雅的方式也修复以下代码:

#include <vector>
#include <map>
#include <set>
using namespace std;

typedef map< int, int > row_t;
typedef vector< row_t > board_t;
typedef row_t::iterator area_t;

bool operator< ( area_t const& a, area_t const& b ) {
    return( a->first < b->first );
};

int main( int argc, char* argv[] )
{
    int row_num;
    area_t it;

    set< pair< int, area_t > > queue;
    queue.insert( make_pair( row_num, it ) ); // does not compile
};

修复它的一种方法是将less <to namespace命名为std(我知道,   你不应该这样做.)

namespace std {
    bool …

为什么如果我们在基类中有纯虚拟赋值运算符,那么我们在派生类上实现该运算符,它会在基类上给出链接器错误？

目前我在http://support.microsoft.com/kb/130486上只有以下说明,它说该行为是设计的,因为正常的继承规则不适用.

我不清楚,为什么它会通过设计产生链接器错误？有人可以给我更明确的解释吗？

编辑:添加了我发生错误的简化代码:

class __declspec(dllexport) BaseClass {
public:
    int memberA;
    virtual BaseClass& operator=(const BaseClass& rhs) = 0;
};

class __declspec(dllexport) DerivedClass : public BaseClass {
public:
    int memberB;
    DerivedClass():memberB(0) {}
    virtual BaseClass& operator=(const BaseClass& rhs) {
        this->memberA = rhs.memberA;
        this->memberB = 1;
        return *this;
    }
};

int main(void)
{
    DerivedClass d1;
    DerivedClass d2;

    BaseClass* bd1 = &d1;
    BaseClass* bd2 = &d2;

    *bd1 = *bd2;
}

如果没有 __declspec(dllexport)和/或没有基类上的纯虚拟运算符=声明,代码将编译时没有错误.

在没有__declspec(dllexport) …

我正在尝试开发一个Android应用程序,它可以在地图上显示各种网络运营商的信号强度.问题是改变网络运营商的唯一方法是手工完成.

关于如何在不手动更改信息的情况下获取此信息的任何想法？我认为有内部/私人Android类可以做到这一点.

我想扩展.NET的内置Color结构来添加像+或的新运算符-.
我将使用它们像:

Color c1 = Color.FromName("Red");
Color c2 = Color.FromName("Blue");
Color result = c2 - c1;

可能吗？如果有,怎么样？

我对scala很新.我浏览了这本书,并在代码中绊倒了这两个操作符.他们在做什么 ？

我正在尝试实现一个简单的比较器,用于根据数组"_vec"中的值对索引进行排序.我收到"无效<运营商"运行时错误消息.我无法理解以下代码有什么问题:

class Compare{
vector<int>& _vec;
public:
    Compare(vector<int>& vec) : _vec(vec) {}
    bool operator()(size_t i, size_t j){
        if(_vec[i] != _vec[j])
        return _vec[i] < _vec[j];
        else
        return (double)rand()/RAND_MAX < 0.5; 
    }
};

我正在使用以下函数调用:

sort(inds.begin(),inds.end(),Compare(vals));

其中inds只是一个包含索引从1到15(比如说)的数组,而vals是长度为15的数组,其中包含一些我希望计算其排序索引的值.总体目标是在val中的两个(或更多)条目相等时随机化排序顺序.有帮助吗？

我有一个重载下标运算符的类:

class SomeClass
{
public:

   int& operator[] (const int idx)
   {
      return someArray[idx];
   }  

private:

   int someArray[10];
};

这当然允许我像这样访问someArray成员的数组元素:

SomeClass c;
int x = c[0];

但是,SomeClass的某些实例将包含在boost共享指针中:

boost::shared_ptr<SomeClass> p(new SomeClass);

但是,为了使用下标运算符,我必须使用更详细的语法,这种语法会破坏下标运算符重载的简洁性:

int x = p->operator[](0);

有没有办法以更简单的方式访问下标运算符？

#include <iostream>
#include <sstream>

class Vector
{
    double _x;
    double _y;
public:
    Vector(double x, double y) : _x(x), _y(y) {}
    double getX() { return _x; }
    double getY() { return _y; }

    operator const char*()
    {
        std::ostringstream os;
        os << "Vector(" << getX() << "," << getY() << ")";
        return os.str().c_str();
    }
};
int main()
{
    Vector w1(1.1,2.2);
    Vector w2(3.3,4.4);
    std::cout << "Vector w1(" << w1.getX() << ","<< w1.getY() << ")"<< std::endl;
    std::cout << "Vector w2(" << w2.getX() << ","<< …

我试图在python中实现除法运算符的重载.

class Fraction:
    def __init__(self,top,bottom):
        def gcd(m, n):
            while m % n != 0:
                old_m = m
                old_n = n
                m = old_n
                n = old_m % old_n
            return n
        common = gcd(top,bottom)
        self.num = top/common
        self.den = bottom/common
    def __str__ (self):
        return str(self.num) + "/" + str(self.den)
    def get_num(self):
        return self.num
    def get_den(self):
        return self.den
    def __add__(self, other_fraction):
        new_num = self.num * other_fraction.den + self.den * other_fraction.num
        new_den = self.den * other_fraction.den
        return Fraction(new_num, new_den)
    def __sub__(self, other_fraction):
        new_num …

我正在阅读有关Ruby序列化的信息(http://www.skorks.com/2010/04/serializing-and-deserializing-objects-with-ruby/),并且遇到了以下代码.$ /是什么意思？我假设$指的是一个对象？

 array = []
 $/="\n\n"
 File.open("/home/alan/tmp/blah.yaml", "r").each do |object|
   array << YAML::load(object)
 end