One way you could do this would be to make the constructors private and only allow construction through a static method that returns a pointer. For example: class Foo { public: ~Foo(); static Foo* createFoo() { return new Foo(); } private: Foo(); Foo(const Foo&); Foo& operator=(const Foo&); };
The four operators mentioned in the original posting, =, (), -> and [], must indeed be implemented as non-static member functions (by respectively C++98 §13.5.3/1, §13.5.4/1, §13.5.5/1 and §13.5.6/1). Bjarne Stroustrup’s rationale was, as I recall from earlier debates on the subject, to retain some sanity in the language, i.e. having at least some things … Read more
The unary prefix operator &, when applied to an object, yields the address of the object: &obj. The type modifier &, when applied to a variable about to be declared, will modify the variable’s type to be a reference type: int&. The same applies to *: When applied as a unary prefix operator to a … Read more
It is because name lookup stops if it finds a name in one of your bases. It won’t look beyond in other bases. The function in B shadows the function in A. You have to re-declare the function of A in the scope of B, so that both functions are visible from within B and … Read more
Reviewing the basic terminology It’s usually good enough – unless you’re programming assembly – to envisage a pointer containing a numeric memory address, with 1 referring to the second byte in the process’s memory, 2 the third, 3 the fourth and so on…. What happened to 0 and the first byte? Well, we’ll get to … Read more
You have to understand the forwarding problem. You can read the entire problem in detail, but I’ll summarize. Basically, given the expression E(a, b, … , c), we want the expression f(a, b, … , c) to be equivalent. In C++03, this is impossible. There are many attempts, but they all fail in some regard. … Read more
All you need to do is declare the class’ new operator private: class X { private: // Prevent heap allocation void * operator new (size_t); void * operator new[] (size_t); void operator delete (void *); void operator delete[] (void*); // … // The rest of the implementation for X // … }; Making ‘operator new’ … Read more
I want to pass a shared pointer to a function. Can you help me with that? Sure, I can help with you that. I assume you have some understanding of ownership semantics in C++. Is that true? Yeah, I’m reasonably comfortable with the subject. Good. Ok, I can only think of two reasons to take … Read more
There are two distinct forms of “properties” that turn up in the standard library, which I will categorise as “Identity oriented” and “Value oriented”. Which you choose depends on how the system should interact with Foo. Neither is “more correct”. Identity oriented class Foo { X x_; public: X & x() { return x_; } … Read more
Warning: this is a really long explanation, but hopefully it really explains not only what SFINAE does, but gives some idea of when and why you might use it. Okay, to explain this we probably need to back up and explain templates a bit. As we all know, Python uses what’s commonly referred to as … Read more