标签: operator-overloading

为什么我不能像这样定义隐式和显式运算符？

    public class C
    {
        public static implicit operator string(C c)
        {
            return "implicit";
        }

        public static explicit operator string(C c)
        {
            return "explicit";
        }
    }

你可以这样做虽然:)

    class Program
    {
        public class A
        {

        }

        public class B
        {
            public static implicit operator A(B b)
            {
                Console.WriteLine("implicit");
                return new A();
            }
        }

        public class C : B
        {
            public static explicit operator A(C c)
            {
                Console.WriteLine("explicit");
                return new A();
            }
        }

        static void Main(string[] args)
        {
            C c = new …

在C++中,你可以在一个类上有一个模板化运算符吗？像这样:

class MyClass {
public:
    template<class T>
    T operator()() { /* return some T */ };
}

这实际上似乎编译得很好,但混淆在于如何使用它:

MyClass c;
int i = c<int>(); // This doesn't work
int i = (int)c(); // Neither does this*

它编译的事实向我暗示它是可行的,我只是对如何使用它感到茫然!有什么建议,或者这种使用方法是非首发？

下面的snipplet是否正确用于取消定义所有其他方法和类的构造函数？

struct Picture {

  // 'explicit': no accidental cast from string to Picture
  explicit Picture(const string &filename) { /* load image from file */ }

  // no accidental construction, i.e. temporaries and the like
  Picture() = delete;

  // no copy
  Picture(const Picture&) = delete;

  // no assign
  Picture& operator=(const Picture&) = delete;

  // no move
  Picture(Picture&&) = delete;

  // no move-assign
  Picture& operator=(Picture&&) = delete; // return type correct?
};

这会删除每个默认的编译器实现,只留下析构函数,对吧？没有它,我猜这个类(几乎)无法使用,但我也可以删除它,对吗？

Picture&move-assign 的返回类型operator=(Picture&&)是否正确？如果我Picture&&为回归类型写的,它会有所作为吗？

我必须在C++中为具有许多属性的类重载一个==运算符.
当且仅当所有属性相等时,运算符才应返回true.如果这些属性随时间而变化,则快捷方式可能很有用,以避免错误.

是否有比较类中每个属性的快捷方式？

给出类似的泛型类定义

public class ConstrainedNumber<T> :
    IEquatable<ConstrainedNumber<T>>,
    IEquatable<T>,
    IComparable<ConstrainedNumber<T>>,
    IComparable<T>,
    IComparable where T:struct, IComparable, IComparable<T>, IEquatable<T>

如何为它定义算术运算符？

以下内容无法编译,因为'+'运算符不能应用于类型'T'和'T':

public static T operator +( ConstrainedNumber<T> x, ConstrainedNumber<T> y)
{
    return x._value + y._value;
}

正如您所见,泛型类型'T'受'where'关键字约束,但我需要对具有算术运算符的数字类型(IArithmetic？)进行约束.

'T'将是一个原始数字类型,如int,float等.这些类型是否存在'where'约束？

赋值运算符可以使用成员函数重载,但不能使用非成员friend函数重载:

class Test
{
    int a;
public:
    Test(int x)
        :a(x)
    {}
    friend Test& operator=(Test &obj1, Test &obj2);
};

Test& operator=(Test &obj1, Test &obj2)//Not implemented fully. just for test.
{
    return obj1;
}

它会导致此错误:

错误C2801:'operator ='必须是非静态成员

为什么friend函数不能用于重载赋值运算符？编译器允许重载其他运算符,例如+=和-=使用friend.支持的固有问题/限制是operator=什么？

在一些书籍中,经常在互联网上,我看到像" operator==应该被宣布为朋友"这样的建议.

当运营商必须被宣布为朋友以及何时应该被宣布为会员时,我应该如何理解？除了==和之外,最常需要被宣布为朋友的运营商是什么<<？

这个问题的灵感来自以下多重继承重载伪歧义的解决方案,这是一个很好的方法来实现此答案中提出的boost :: variant的lambda访问者:

我想做类似以下的事情:

template <typename ReturnType, typename... Lambdas>
struct lambda_visitor : public boost::static_visitor<ReturnType>, public Lambdas... {
    using Lambdas...::operator(); //<--- doesn't seem to work
    lambda_visitor(Lambdas... lambdas) : boost::static_visitor<ReturnType>() , Lambdas(lambdas)... { }
};

我不确定在打包类型列表中添加使用子句的正确语法是什么.该using条款对于阻止编译器抱怨operator()模糊不清是完全不重要的,因为它们具有所有不同的签名.

据我所知,没有办法做到这一点,但我会问,以防其他人知道如何做到这一点.如何在Delphi中将日期声明为const？

我发现的唯一解决方案是使用数字等价物,这是一种难以维护,因为它不是人类可读的.

const
  Expire : TDateTime = 39895; // Is actually 3/23/2009

我希望能做的是这样的:

const
  Expire : TDateTime = TDateTime ('3/23/2009');

要么

const
  Expire : TDateTime = StrToDate('3/23/2009');

所以让我知道这是一个功能请求,还是我错过了如何做到这一点(是的,我知道这似乎是一件奇怪的事情......)

如何|=在强类型(作用域)enum(在C++ 11,GCC中)重载操作符？

我想在强类型枚举上测试,设置和清除位.为何选择强类型？因为我的书说这是好习惯.但这意味着我必须static_cast<int>到处都是.为了防止这种情况,我重载了|和&运算符,但我无法弄清楚如何在枚举上重载|=运算符.对于一个类,您只需将运算符定义放在类中,但对于在语法上似乎不起作用的枚举.

这是我到目前为止:

enum class NumericType
{
    None                    = 0,

    PadWithZero             = 0x01,
    NegativeSign            = 0x02,
    PositiveSign            = 0x04,
    SpacePrefix             = 0x08
};

inline NumericType operator |(NumericType a, NumericType b)
{
    return static_cast<NumericType>(static_cast<int>(a) | static_cast<int>(b));
}

inline NumericType operator &(NumericType a, NumericType b)
{
    return static_cast<NumericType>(static_cast<int>(a) & static_cast<int>(b));
}

我这样做的原因:这是它在强类型C#中的工作方式:一个枚举只有一个结构,其中包含一个基础类型的字段,并在其上定义了一堆常量.但它可以包含任何适合枚举隐藏字段的整数值.

似乎C++枚举的工作方式完全相同.在两种语言中,强制转换都需要从枚举变为int,反之亦然.但是,在C#中,默认情况下,按位运算符会重载,而在C++中,它们不会重载.