l’ho “non possono apparire in una costante espressione” quando si utilizza il modello

template < int >  
  class CAT  
  {};  

  int main()  
  {  
     int i=10;  
     CAT<(const int)i> cat;  
     return 0; //here I got error: ‘i’ cannot appear in a constant-expression  
  }  

anche

   int i=10;  
   const int j=i;  
   CAT<j> cat; //this still can not work

ma ho convertire i const int ,perché compilatore ancora segnalare errore ?

la mia piattaforma è ubuntu,la versione di gcc 4.4.3

Grazie,

==============

Grazie a tutti per il vostro ingresso, ma in alcuni casi,ho bisogno di un non-const variabile ,

per esempio:

  //alloperations.h   
  enum OPERATIONS  
  {  
       GETPAGE_FROM_WEBSITE1,  
       GETPAGE_FROM_WEBSITE2,  
       ....  
  };  


  template< OPERATIONS op >  
  class CHandlerPara  
  {  
       static string parameters1;         
       static string parameters2;         
       ....  
       static void resultHandler();  
  };     


  //for different operations,we need a different parameter, to achieve this  
  //we specified parameters inside CHandler, for  example  

  template<>  
  string CHandlerPara< GETPAGE_FROM_WEBSITE1 >::parameters1("&userid=?&info=?..")  

  template<>  
  string CHandlerPara< GETPAGE_FROM_WEBSITE1 >::parameters2("...")  

altro modulo si utilizza questo modello per ottenere il corrispondente parametro

e forse specilize il resultHandler funzione per un comportamento speciale

  • Ricordate: Un sacco di volte, quando si ricevono errori di una linea, è un sacco di volte in una riga sopra. Come James risposta dimostra.
  • Solo perché una è di tipo const non significa che il suo valore.
  • Ripeto: Solo perché una è di tipo const non significa che il suo valore è. Si potrebbe dire f(rand());, o int i = rand(). Basta schioccare le const del tipo non significa nulla.
  • Esattamente dov’è che ho intenzione di essere impostato? Si aspetta l’utente a fornire tali in fase di esecuzione? O sarà cambiato in fase di compilazione? Se quest’ultimo, quindi utilizzare una riga di comando costruire come “g++ -Di=10” e non definire “int i” nel codice. (Meglio usare un modo più descrittivo e il nome univoco che “io” in questo caso).
  • Grazie mille GMan,ho ricevuto la tua idea
InformationsquelleAutor camino | 2010-10-21



2 Replies
  1. 18

    Un non-modello di tipo di argomento deve essere una costante della fase di compilazione. Il Casting di un int per un const int non è una costante della fase di compilazione. È necessario utilizzare 10 direttamente:

    CAT<10> cat;

    o fare i un const int:

    const int i = 10;
    CAT<i> cat;
    • Grazie a voi il vostro ingresso, ma in alcuni casi,ho bisogno di un non-const variabile , ad esempio: void f(const int j) { CAT<p> gatto; }
    • Quindi non può essere un modello. Modelli fare tipi, i tipi sono in fase di compilazione costrutti. Se si dispone di un esempio più concreto, abbiamo potuto aiutare.
    • Ciao GMan,devo aggiungere l’esempio
    • Non è troppo concreto però. Ancora non ho capito cosa stai cercando di non.
  2. 9

    È importante capire quali modelli sono: sono un codice che reinstantiated per ogni combinazione di specifici tipi di modelli o di valori.

    void f(const int j) { CAT<j> cat; } 

    Questo è chiedere f per creare un diverso tipo di CAT<> ogni volta che viene eseguito, ma i modelli devono essere risolti a tempo di compilazione. Concettualmente, il compilatore potrebbe affrontare se si è sempre e solo chiamato f() con i valori che si potrebbe risolvere in fase di compilazione, ma se hai intenzione di che si può semplicemente scrivere:

    template <int N>
    void f() { CAT<N> cat; }

    Questo sarà generare più f() funzioni che la creazione personalizzata di GATTO<> le istanze.

    Il C++ Standard non anche chiedere al compilatore di accettare provvisoriamente void f(const int j) versione – non sarebbe dubbia bagagli in giro in attesa di esito negativo quando qualcuno è andato a usarlo con un valore determinato in fase di esecuzione. Persone in cerca di interfaccia, senza l’intera attuazione aspetta f() per essere richiamabile con tali valori di runtime – ad esempio f(atoi(argv[2])). O, si potrebbe mettere for (int i = 0; i < 100000; ++i) f(i). Se f() prende un int a run-time, e dire che la dà a CAT come argomento del costruttore (cioè come un parametro in fase di esecuzione, piuttosto che un parametro di modello) poi che è bene e dandy, ma se il compilatore era di creare un’istanza di 100.000 versioni di f() ognuno specializzato CAT<>s con i valori successivi di i/N il programma eseguibile di dimensioni potrebbe diventare enorme (ottimizzazione – se abilitato, può ridurre tale).

Lascia un commento