标签: operator-overloading

假设我需要重载全局::operator new() 以便为每个分配的对象存储额外的数据.所以基本上它会这样工作:

• 对于每次调用global ::operator new(),它将传递对象大小并添加额外数据的大小
• 它将分配一个在前一步推导出的大小的内存块
• 它会将指针偏移到未被额外数据占用的块部分,并将该偏移值返回给调用者

::operator delete() 反向移动指针,访问额外数据,释放内存.

现在的问题是如何分配内存？当然我可以调用malloc()或者某些特定于平台的功能(通常是这样做的).但通常当我需要在C++中分配原始内存时,我会调用::operator new().我可以调用原始文件::operator new()从我重载的全局内部进行内存分配::operator new()吗？

是否可以在C#中重载默认函数运算符((运算符)？如果是这样 - 怎么样？如果没有,是否有解决方法来创建类似的影响？

谢谢,
阿萨夫

编辑:
我试图给一个类一个默认运算符,类似于:

class A {
    A(int myvalue) {/*save value*/}

    public static int operator() (A a) {return a.val;}
    ....
   }

...
A a = new A(5);
Console.Write(A());

编辑2:
我已阅读规范,我知道没有直接的方法来做到这一点.我希望有一个解决方法.

编辑3:动机是使一个类或一个实例表现得像一个函数,以创建一个方便的日志记录界面.顺便说一句,这在C++中是可行和合理的.

我已经创建了一个列表类作为替换我的程序中的可变参数函数的方法,该程序用于初始化需要包含更改的元素列表的对象.list类有一个我非常喜欢的用法语法.但是我之前没有看过它,所以我想知道我是不是因为这个事实而不应该使用它？列表类的基本实现看起来像这样......

#include <list>
#include <iostream>
template<typename T>
struct list
{
    std::list<T> items;
    list(const list&ref):items(ref.items){}
    list(){}
    list(T var){items.push_back(var);}
    list& operator,(list add_){
        items.insert(items.end(),add_.items.begin(), add_.items.end());
        return *this;
    }
    list& operator=(list add_){
        items.clear();
        items.insert(items.end(),add_.items.begin(), add_.items.end());
        return *this;
    }
    list& operator+=(list add_){
        items.insert(items.end(),add_.items.begin(), add_.items.end());
        return *this;
    }
};

这允许我在代码中使用它,如此...

struct music{
//...
};
struct music_playlist{
    list<music> queue;
//...
};
int main (int argc, const char * argv[])
{
    music_playlist playlist;
    music song1;
    music song2;
    music song3;
    music song4;
    playlist.queue = song1,song2; // The queue now …

我一直在寻找一种解决方案来同时写入文件和控制台.我发现了一个很好的解决方案在这里.

当我在C++ 11之前工作时,我不得不对Orbit中Lightness Races的代码进行一些小改动:

#include <iostream>
#include <fstream>
#include <string>

struct OutputAndConsole : std::ofstream
{
    OutputAndConsole(const std::string& fileName)
       : std::ofstream(fileName.c_str())   // constructor taking a string is C++11
       , fileName(fileName)
    {};

    const std::string fileName;
};

template <typename T>
OutputAndConsole& operator<<(OutputAndConsole& strm, const T& var)
{
    std::cout << var;    
    static_cast<std::ofstream&>(strm) << var;
    return strm;
};

它很好地工作除了一个小东西需要困惑我.如果我像这样使用它:

int main(){
    OutputAndConsole oac("testLog.dat");
    double x = 5.0;
    oac << std::endl;
    static_cast<OutputAndConsole&>(oac << "foo \n" << x << "foo").operator<<(std::endl);  
    oac << "foo" << std::endl; …

我在关于SO的问题上阅读了以下内容:

'7'+ 4给出'74',而'7' - 4给出了JavaScript

为什么会这样？

我试图重载一些运算符:

/* Typedef is required for operators */
typedef int Colour;

/* Operators */
Colour operator+(Colour colour1, Colour colour2);
Colour operator-(Colour colour1, Colour colour2);
Colour operator*(Colour colour1, Colour colour2);
Colour operator/(Colour colour1, Colour colour2);

我为每次尝试重载都收到此错误:

expected '=', ',', ';', 'asm' or '__attribute__' before '+' token

关于运算符重载,我找不到任何好的文档.谷歌搜索结果导致使用类的C++教程.在C中没有类.谁能帮我？谢谢.

我对它们之间的差异感到有点困惑

Type  operator +  (const Type &type);
Type &operator += (const Type &type);

和

friend Type  operator +  (const Type &type1, const Type &type2);
friend Type &operator += (const Type &type1, const Type &type2);

哪种方式是首选,它们看起来像什么,什么时候应该使用？

在C++中,我知道有两种方法可以重载.我们可以在内部(如类a)或外部(如类b)重载它.但是,问题是,这两者在编译时或运行时是否存在差异？

class a
{
public:
    int x;
    a operator+(a p) // operator is overloaded inside class
    {
        a temp;
        temp.x = x;
        temp.x = p.x;
        return temp;
    }
};

class b
{
public:
    friend b operator+(b, b);
    int x;
};

b operator+(b p1, b p2) // operator is overloaded outside class
{
    p1.x += p2.x;
    return p1;
}

我有一个类Base定义explicit operator bool:

struct Base {
    virtual explicit operator bool() const {
        return true;
    }
};

我有一个子类Derived,定义operator bool:

struct Derived : Base {
    operator bool() const override {
        return false;
    }
};

正如你可以观察到的那样,Derived::operator bool明确没有标记explicit,但是标记了override,所以我期望编译器抱怨.然而,gcc和clang似乎都同意这是有效的.我的期望不合理吗？

而且,如果我使用如下的类,TakesBool(base)不编译(如预期的那样),但是TakesBool(derived):

void TakesBool(bool b) {}

int main() {
    //Base base;     TakesBool(base); // compilation error (as expected)
    Derived derived; TakesBool(derived);
    return 0;
}

这似乎表明Derived有一个(非explicit)operator …

例如,

class Person{
        string name;
    public:
        T& operator*(){
            return name;
        }
        bool operator==(const Person &rhs){
            return this->name == rhs.name;
        }
        bool operator!=(const Person &rhs){
            return !(*this == rhs); // Will *this be the string name or the Person?
        }
}

如果*this最终提领this的string,而不是一个Person,是有维持的使用一种解决方法*作为类外引用操作？

如果我*不放弃而不放弃使用,那将是一个很大的障碍*this.