You can overload operator[] to return an object on which you can use operator[] again to get a result. class ArrayOfArrays { public: ArrayOfArrays() { _arrayofarrays = new int*[10]; for(int i = 0; i < 10; ++i) _arrayofarrays[i] = new int[10]; } class Proxy { public: Proxy(int* _array) : _array(_array) { } int operator[](int index) … Read more
you can use the ‘implicit’ keyword to create an overload for the assignment: Suppose you have a type like Foo, that you feel is implicitly convertable from a string. You would write the following static method in your Foo class: public static implicit operator Foo(string normalString) { //write your code here to go from string … Read more
Is it possible to overload the default function operator (the () operator) in C#? If so – how? In C#, only methods and delegates make sense to invoke as functions. In C#, delegates are as close as you get to the C++ function objects you are asking about. If not, is there a workaround to … Read more
You need to specify T. int i = c.operator()<int>(); Unfortunately, you can’t use the function call syntax directly in this case. Edit: Oh, and you’re missing public: at the beginning of the class definition.
This is a possible solution. It will always choose the operator with the highest alignment in a given hierarchy: #include <exception> #include <iostream> #include <cstdlib> // provides operators for any alignment >= 4 bytes template<int Alignment> struct DeAllocator; template<int Alignment> struct DeAllocator : virtual DeAllocator<Alignment/2> { void *operator new(size_t s) throw (std::bad_alloc) { std::cerr << … Read more
You’re missing a key exception to the usual behaviour: when the right-hand operand is an instance of a subclass of the class of the left-hand operand, the special method for the right-hand operand is called first. See the documentation at: http://docs.python.org/reference/datamodel.html#coercion-rules and in particular, the following two paragraphs: For objects x and y, first x.__op__(y) … Read more
There is no shortcut. You will have to list everything. Some sources of error can be reduced by introducing a member function named tied() like: struct Foo { A a; B b; C c; … private: auto tied() const { return std::tie(a, b, c, …); } }; So that your operator== can just use that: … Read more
As “jamesdlin” already noted, the * and -> operators can be overloaded for class types. And then the two expressions (*ptr).method() and ptr->method() can have different effect. However, for the built-in operators the two expressions are equivalent. The -> operator is more convenient when you’re following a chain of pointers, because . has higher precedence … Read more
It’s actually quite straight forward. For t[1], overload resolution has these candidates: Candidate 1 (builtin: 13.6/13) (T being some arbitrary object type): Parameter list: (T*, ptrdiff_t) Candidate 2 (your operator) Parameter list: (TData<float[100][100]>&, something unsigned) The argument list is given by 13.3.1.2/6: The set of candidate functions for overload resolution is the union of the … Read more
inline NumericType& operator |=(NumericType& a, NumericType b) { return a= a |b; } This works? Compile and run: (Ideone) #include <iostream> using namespace std; 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) | … Read more