How can I use more parameters in a new call?

Question

Sorry if "new call" isn't a C++-term. If it is not, tell me what's the right term. I'm a C programmer starting with C++. I have struct A that I want to initialize it using paramereters in new operator. Like this:

A* a = new A(foo, baa);

So, I tried to use it defining function: void* A::operator new(T a, T B) { ... }

But I get an compiler-error:

error: 'operator new' takes type size_t ('unsigned int') as first parameter

Also, not sure if it's relevant but the function that overload parameter of size_t type is already defined, like this:

void* A::operator new(size_t size) { ... }

Answer 1

You don't need to overload operator new for this. You just want a constructor:

class A
{
    public:
        A(FooType foo, BaaType baa);
};

A::A(FooType foo, BaaType baa)
{
    // initialize object here
}

You can then write (assuming you have obtained a variable foo of type FooType and so on):

A *a = new A(foo, baa);

Answer 2

The way it's done in C++ is by having a non-default constructor for A.

struct A {
  int a;
  int b;
  explicit A(int a_, int b_) : a(a_), b(b_) {}
};

...
A * a = new A(1, 2);
assert(a->a == 1);
assert(a->b == 2);

The expressions after the colon (:) are the constructor's initialization list - they perform initialization of the members during construction. They are usually more efficient than the more C-style variant:

A::A(int a_, int b_) { a = a_; b = b_; }

In idiomatic C++, you always want to use the initialization lists where possible. You also do not want to use naked pointers, so it'll be better to write:

std::shared_ptr<A> a(new A(1, 2));
// or
std::unique_ptr<A> a(new A(1, 2));

The shared_ptr is for when multiple entities may need to hold the instance and there's no clear scope where it should exist. The unique_ptr is for when there's a clear scope where the object should exist. The unique_ptr will delete a when it goes out of scope. The shared_ptr will perform the deletion when the last shared_ptr referencing given object goes out of scope.

The reason to use the explicit keyword is to prevent the use of given constructor in automatic conversions. In pre-C++11 times, it had no effect on multi-argument constructors. But in C++11, it has effect when you use brace intialization.

Answer 3

You need to distinguish between the new operator and the constructor: The new operators do nothing more or less than malloc(), they allocate a slap of memory. A constructor then initializes that slap of memory to make it a valid object of type A.

The confusion for you arises from the fact, that the new keyword does both, allocation and construction. The line

A* foo = new A(...);

first calls a new operator to get the memory, then it calls the appropriate constructor, passing it the given arguments, to construct the object.

So, as the others have already pointed out, you need to add a constructor with your desired arguments, not a new operator:

class A {
public:
    A(int arg1, int arg2);
    int member1, member2;
};

A::A(int arg1, int arg2) : member1(arg1), member2(arg2) {
    //Do additional stuff that cannot be achieved by calling the constructors of the members alone.
}

Note, that in this code, you explicitly call the constructors of the data members of A in the initializer list (the part between the : and the {.