Come verificare se un tipo è un typedef di int

Question

In C++, voglio avere una classe i cui costruttori sono i seguenti:

class A { 
    explicit A(A* other) { ... } 
    explicit A(intptr_t other) { ... } 
}; 

Il problema è se l'utente inizializza con

A a(0); 

Quindi, su un sistema a 64 bit, il compilatore si lamenterà che non sa se 0 deve essere convertito in A* o intptr_t, che è abbastanza giusto. Come voglio che questo semplice notazione per lavorare, ho aggiunto il seguente costruttore:

explicit A(int a) { assert(a==0); ... } 

L'asserzione è perché questo è l'unico intero questo ha un senso per. Ora, il problema sorge con un sistema a 32 bit, in cui intptr_t è in realtà ... int! Così ora, il sistema lamenta che ci sono due costruttori che assumono lo stesso tipo di parametro (che, di nuovo, è abbastanza giusto).

Quindi la mia domanda è: esiste un modo con il preprocessore per rilevare che è in realtà intptr_tint e, in quel caso, non compilare il costruttore con int. Oppure, esiste un altro modo per rendere valida la notazione A a(0) senza aggiungere la funzione di costruzione con int, ma senza rimuovere nessuno dei due primi costruttori (e non renderli impliciti neanche).

Answer 1

Qualcosa di simile

#if INTPTR_MAX == INT_MAX 

potrebbe fare il trucco, ma sarà ancora tradurrà in vera dove long e int sono della stessa dimensione, e ptrint_t è un typedef per long. Un'altra possibilità (ma non so se è possibile utilizzarla o meno) sarebbe utilizzare uintptr_t, anziché intptr_t.

Oltre questi: il preprocessore non conosce i tipi, quindi il problema non può essere risolto lì. Dovrai utilizzare una sorta di meta-programmazione trucco: si rende il costruttore int un modello, utilizzando boost::enable_if per attivarlo solo se l'argomento ha tipo int. Se ptrint_t è int, la funzione attivata non sarà mai utilizzata, perché non sarà mai una corrispondenza migliore della funzione non modello con la stessa firma. Se ptrint_t non è int, l'istanziazione del modello sarà una corrispondenza migliore quando l'argomento ha tipo int. (Si noti che non ho mai provato io stesso:. Suona per me come dovrebbe essere possibile, ma io non sono che la familiarità con boost::enable_if per essere sicuri)

Answer 2

Perché non semplice implemment un senza parametri costruttore che funziona come se other fosse 0?Se, per qualche motivo non si vuole, io suggerisco di usare caratteri morfologici, purché si disponga di accesso a C++ 11 compilatore o spinta:

class A { 
public: 
    explicit A(A* other) { ... } 
    explicit A(intptr_t other) { ... } 

    template <class T> 
    explicit A(T other) 
    { 
     static_assert(std::is_convertible<T, intptr_t>::value, "Could not convert value to intptr_t"); 
     static_assert(std::is_integral<T>::value, "Argument must be integral"); 
     intptr_t p = other; 
     ... 
    } 
}; 

È possibile liberarsi di asserzioni statiche e di tipo verifiche, ma allora invece di errore di compilazione si ottiene un messaggio di avviso (a seconda del vostro livello di avviso, può anche essere trasformato in un errore) quando si effettuano le seguenti operazioni:

A a(0.0f); 

Answer 3

c'è un altro modo per rendere la notazione A a(0) valida

Basta introdurre un costruttore template.

class A { 
public: 
    template<typename T> 
    explicit A (T t) { assert(t==0); } // explicit matters ? 

    explicit A(A* other) { ... } 
    explicit A(intptr_t other) { ... } 
}; 

Questo risolverà il tuo problema a 32 e 64 bit!

Answer 4

È inoltre possibile passare un parametro che determina quale è chiamato:

struct TakePtr{}; 
struct TakeInt{}; 

class A { 
    A(A* other, const TakePtr&) { ... } 
    A(intptr_t other, const TakeInt&) { ... } 
}; 

In questo modo è possibile assicurarsi che il costruttore si chiama:

A a2(0, TakeInt());  // calls the 2nd constructor, taking int 
A a1(&a2, TakePtr()); // calls the 1st constructor, taking a pointer 

Answer 5

Credo che la cosa più semplice è quello di dichiarare tutti i 6 costruttori (int, long, long long e le loro varianti senza segno), invece di usare intptr_t.