new-operator

Im trying to understand why new runs against the function rather than the return of the function in the example y = : function returnFunction(){ return function blah(str){ this.x = str; return this;}} y = new returnFunction()("blah") // output: Window {x: "blah"; top: Window, window: Window, location: Location, ....} x = new (returnFunction())("blah") // output: blah {x: "blah"} z = new function blah(){return this;}() // output: blah {} zz = new function(){return this;}() //note the missing function name // output: Object {} b = new function blib(str){this.x = str; return this} // blib {x:

I saw some code as below during a peer-code-review session: char *s = new char[3]; *s++ = 'a'; *s++ = 'b'; *s++='\0'; delete []s; // this may or may not crash on some or any day !! Firstly, I know that in Standard C++, pointing to one-past the array-size is O.K. though accessing it results in undefined behaviour. So I believe the last line *s++='\0' is fine. But if I recall correctly, the C++ standard mandates that delete should be supplied the same pointer that new returned. This I believe means that the returned pointer must not be tampered-with. I guess it is because new might keep some

How do I make sure that a certain class is only instantiated by a factory and not by calling new directly? EDIT: I need the factory to be a separate class (for dependency injection purposes) so I can't make it a static method of the class to be instantiated, and so I can't make new private. If, for some reason, you need the factory and the constructed class to be in separate assemblies (which means simply using internal won't work), and you can ensure that your factory gets a chance to run first, you can do this: // In factory assembly: public class Factory { public Factory() { token = new

I've got this trivial class hierarchy: class Base { public: virtual int x( ) const = 0; }; class Derived : public Base { int _x; public: Derived( int x ) : _x(x) { } int x( ) const { return _x; } }; If I use malloc to allocate an instance of Derived , and then try to access the polymorphic function x , program crashes (I get a segmentation fault): int main( ) { Derived *d; d = (Derived*) malloc( sizeof(Derived) ); *d = Derived( 123 ); std::cout << d->x() << std::endl; // crash return 0; } Of course my actual application is a lot more complex (it's a sort of memory pool). I'm pretty sure it's

I want to override delete operator in my class. Here's what I am trying to do,but not succeeding. class Complex{ void *operator new(size_t s); void operator delete(void *ptr); }; void Complex::operator delete(void *ptr){ delete ptr; } I get the error: deleting void* is undefined As the error message indicates, you can't delete a void* . Try this: // See http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=40 #include <new> // for size_t class Complex { public: Complex() {} ~Complex() {} static void* operator new (size_t size) { return new char[size]; } static void operator delete

Short Version For those who don't have the time to read my reasoning for this question below: Is there any way to enforce a policy of "new objects only" or "existing objects only" for a method's parameters ? Long Version There are plenty of methods which take objects as parameters, and it doesn't matter whether the method has the object "all to itself" or not. For instance: var people = new List<Person>(); Person bob = new Person("Bob"); people.Add(bob); people.Add(new Person("Larry")); Here the List<Person>.Add method has taken an "existing" Person (Bob) as well as a "new" Person (Larry), and