resolving C++ operator new ambiguity (how to force it)?

Question

My code (not yet released, in file iaca.hh) is on pastebin: Basile Iaca C++ new conflict I'm using GCC 4.6 on Debian/Linux/Sid AMD64 with the C++11 dialect.

g++  -std=c++0x -Wall -Wextra -g -O -flto -I/usr/local/include -o iaca.hh.gch iaca.hh 
iaca.hh:631:2: warning: #warning should implement the methods [-Wcpp]
iaca.hh: In static member function 'static IaDictionnaryItem* IaDictionnaryItem::make()':
iaca.hh:964:46: error: request for member 'operator new' is ambiguous
/usr/local/include/gc/gc_cpp.h:304:14: error: candidates are: static void* gc::operator new(size_t, void*)
/usr/local/include/gc/gc_cpp.h:296:14: error:                 static void* gc::operator new(size_t, GCPlacement)
/usr/local/include/gc/gc_cpp.h:293:14: error:                 static void* gc::operator new(size_t)
iaca.hh:675:7: error:                 static void* IaAnyValue::operator new(size_t, IaAnyValue::allocate_new_value_st)
iaca.hh:667:7: error:                 static void* IaAnyValue::operator new(size_t, size_t, IaAnyValue::allocate_new_value_st)

I can't figure out what is the right syntax for forcing operator new. I want the one from my class IaAnyValue to be called in my function IaDictionnaryItem::make at the end of my iaca.hh file

I've introduced the empty allocate_new_value to solve the ambiguity, without success.

I tried without success

IaDictionnaryItem* IaDictionnaryItem::make() {
  return new(IaAnyValue::allocate_new_value) IaDictionnaryItem;
}

and

IaDictionnaryItem* IaDictionnaryItem::make() {
  return IaAnyValue::operator new(IaAnyValue::allocate_new_value) IaDictionnaryItem;
}

From what I know, the operator new is always called with sizeof (*this) as implicit first argument, etc.

Some motivations about my question is in this question about Boehm's GC & C++. Please, don't tell me I should not use Boehm's GC. I need to use it (otherwise I won't use C++).

What is the right syntax to force the good operator new to be called?

I want the Boehm's GC allocator to be used. It is available thru the gc_cleanup class, which is in class IaItemValue : public IaAnyValue, gc_cleanup and also as the new in my class IaAnyValue (the only super-class of IaDictionnaryItem) I agree there is ambiguity, I just don't guess the syntax to force it.

So how should I code my trivial IaDictionnaryItem::make at the end of the file to get it compiled successfully?

For readability, I would prefer calling IaAnyValue::operator new with sz=sizeof(*this) i.e. sizeof(IaDictionnaryItem), gap=0 and al=allocate_new_value. I just can't figure out the syntax to force this particular one to be called (of course, I still want the constructor of IaDictionnaryItem to be called inside IaDictionnaryItem::make).

I've tried to force the gc::operator new(size_t size, GCPlacement gcp) (the gc class is inherited by  gc_cleanup from <gc/gc_cpp.h>) using

IaDictionnaryItem* IaDictionnaryItem::make() {
  return new (UseGC) IaDictionnaryItem;
}

My make function is a static function returning a new instance of my object. Remember that I'm using Beohm's GC, and it will eventually release the memory used (and delete the object) when no pointers point to it.

But I'm still getting

iaca.hh: In static member function 'static IaDictionnaryItem* IaDictionnaryItem::make()':
iaca.hh:962:22: error: request for member 'operator new' is ambiguous
/usr/local/include/gc/gc_cpp.h:304:14: error: candidates are: static void* gc::operator new(size_t, void*)
/usr/local/include/gc/gc_cpp.h:296:14: error:                 static void* gc::operator new(size_t, GCPlacement)
/usr/local/include/gc/gc_cpp.h:293:14: error:                 static void* gc::operator new(size_t)
iaca.hh:675:7: error:                 static void* IaAnyValue::operator new(size_t, IaAnyValue::allocate_new_value_st)
iaca.hh:667:7: error:                 static void* IaAnyValue::operator new(size_t, size_t, IaAnyValue::allocate_new_value_st)

Regards.

EDIT: Here is simple example of the problem:

#include <cstddef>
struct A {};
struct B { void* operator new(std::size_t, A); };

struct C {};
struct D { void* operator new(std::size_t, C); };

struct E : B, D {};

int main()
{
    //I want to use `void* D::operator new(std::size_t, C);` to allocate memory
    //but it will not compile because the call to operator new is ambiguous.
    new(C()) E;
}

Answer 1

Your problem is a multiple inheritance issue. Notice that the class IaItemValue inherits from both IaAnyValue and gc_cleanup (and IaDictionnaryItem inherits from IaItemValue), both of which provide overloads for operator new. In order to resolve this, you can add the following line to the class definition for IaDictionnaryItem:

using IaAnyValue::operator new;

Answer 2

In order to understand your problem, I've dug through your code and can make the following assertions:

• IaAnyValue::allocate_new_value is a struct allocate_new_value_st {}
• GCPlacement is an enum { NoGC, PointerFreeGC }

You have three defined new operators:

void* operator new(size_t);               
void* operator new(size_t, GCPlacement);  
void* operator new(size_t, void*);        

You need to be specific about what you call.

To call new(size_t):

new X;

To call new(size_t, GCPlacement):

new(NoGC) X;

To call new(size_t, void*):

allocate_new_value_st Y;
new(&Y) X;