Il C++ 0x consente decltype() nella firma della funzione?

Question

Questa domanda, ovviamente, per scontato che noi non vogliamo utilizzare i modelli di questo tipo (per qualsiasi motivo).

class Product 
{ 
public: 
    Product(decltype(mPrice) price_, decltype(mLabel) label_) // 1. 
     : mPrice(price_), mLabel(label_) 
    {} 

    decltype(mPrice) price() const {return mPrice;} // 2. 
    decltype(mLabel) label() const {return mLabel;} // 2. 


private: 

    float mPrice ; // type might later be changed to more acurate floating point abstraction 
    std::string mLabel; // type might later be changed by a special localization-oriented string 
}; 

La domanda è: sono 1. e 2. ammessi e possibile (o addirittura specificamente definito) in C++ 0x?

Answer 1

Tutto quello che dovete fare è dichiarare mPrice e mLabelprima di utilizzare decltype:

class Product 
{ 
private: 
    float mPrice ; 
    std::string mLabel; 
public: 
    Product(decltype(mPrice) price_, decltype(mLabel) label_) // 1. 
     : mPrice(price_), mLabel(label_) 
    {} 

    decltype(mPrice) price() const {return mPrice;} // 2. 
    decltype(mLabel) label() const {return mLabel;} // 2. 
}; 

Questo compila bene sotto g ++ 4.4 con -std = C++ 0x.

Modifica Il punto è che il compilatore deve essere in grado di analizzare le dichiarazioni di funzione al primo passaggio. Il corpo di una funzione membro può essere compilato dopo che le dichiarazioni dei membri sono state analizzate, ma le dichiarazioni dei membri devono essere immediatamente comprensibili - altrimenti, da dove viene il povero compilatore?

Quindi il tipo di argomento di ogni funzione membro deve essere noto non appena viene rilevato.

Answer 2

Sì, ma con una diversa sintassi:

auto price() -> decltype(mPrice) { return mPrice; } 
auto price() -> decltype(mPrice) { return mPrice; } 

più generale:

auto function(...) -> decltype(EXPRESSION) ... 

function tipo di ritorno sarà il tipo di EXPRESSION

---

EDIT

sul caso 1 non sono sicuro. Non credo sia valido, dal momento che non penso che mPrice sia un'espressione valida in tale contesto: stai usando un membro non statico della funzione (Product::mPrime) senza un oggetto.

La mia ipotesi è anche che se mPrime fosse un membro statico, funzionerebbe.

Answer 3

AFAIK questo è non legale poiché le variabili di istanza non sono nell'ambito dei punti in cui le si utilizzano.

considerare che cosa accadrebbe se si ha le seguenti variabili dichiarate prima della classe:

int mPrice; 
char mLabel; 
class Product 
{ /*...*/ }; 

Nella funzione decleration mPrice legherebbe alla variabile globale piuttosto che il membro di istanza.

Sia g ++ 4.5 che VS10 rifiutano di compilare il codice poiché mPrice e mLabel sono fuori portata.

Tuttavia, questo sembra essere incoerente con i parametri di default.

int mPrice = 3; 
class Product 
{ // ... 
    int foo(int i = mPrice) { return i; } 
}; 

Product p(5.3, "hi"); 
std::cout << p.foo(); 

Questo mi dà un errore di compilazione:

invalid use of non-static data member 'Product::mPrice'

Answer 4

VC++ 2010 compila questo w/o errori:

 

class Product 
{ 
private: 

    float mPrice ; 
    std::string mLabel; 
public: 
    Product(decltype(mPrice) price_, decltype(mLabel) label_) 
     : mPrice(price_), mLabel(label_){} 

    auto price(decltype(mPrice)* p=NULL) const -> decltype(mPrice) {return mPrice;} 

    auto label(decltype(mPrice)* m=NULL) const -> decltype(mLabel) {return mLabel;} 

}; 

ma se rimuovere i parametri predefiniti fittizi dalle dichiarazioni metodi, l'errore si verifica di nuovo. decltype in return type funziona solo se appare anche in qualche parametro funzione (???)

(Mi spiace, capisco che dovrebbe essere un commento, ma sembra interessante e non è conveniente inserire il codice nei commenti)