Espressione costante prevista in C ++

#include  #include  #include  #include  #include  using std::ifstream; using namespace std; int main (void) { int count=0; float sum=0; float maximum=-1000000; float sumOfX; float sumOfY; int size; int negativeY=0; int positiveX=0; int negativeX=0; ifstream points; //the points to be imported from file //points.open( "data.dat"); //points>>size; //cout<<size<<endl; size=100; float x[size][2]; while (count>(x[count][0]); //cout<<"x= "<<(x[count][0])<>(x[count][1]); //cout<<"y= "<<(x[count][1])<<endl;//read in y value count++; } 

Questo programma mi dà l’errore di espressione costante previsto sulla riga in cui dichiaro float x [size] [2]. Perché?

 float x[size][2]; 

Questo non funziona perché gli array dichiarati non possono avere dimensioni di runtime. Prova un vettore:

 std::vector< std::array > x(size); 

O usa nuovo

 // identity::type *px = new float[size][2]; float (*px)[2] = new float[size][2]; // ... use and then delete delete[] px; 

Se non hai a disposizione C ++ 11, puoi usare boost::array invece di std::array .

Se non hai boost disponibile, crea il tuo tipo di array che puoi inserire nel vettore

 template struct array { T data[N]; T &operator[](ptrdiff_t i) { return data[i]; } T const &operator[](ptrdiff_t i) const { return data[i]; } }; 

Per facilitare la syntax del new , è ansible utilizzare un modello di identity che è effettivamente un typedef sul posto (disponibile anche in boost )

 template struct identity { typedef T type; }; 

Se vuoi, puoi anche usare un vettore di std::pair

 std::vector< std::pair > x(size); // syntax: x[i].first, x[i].second 

La matrice verrà allocata in fase di compilazione e, poiché la size non è una costante, il compilatore non può determinare con precisione il suo valore.

Non è ansible avere matrici di lunghezza variabile (come vengono chiamate in C99) in C ++. È necessario utilizzare matrici allocate dynamicmente (se la dimensione varia) o un’espressione costante integrale statica per le dimensioni.

La linea float x[size][2] non funzionerà, perché gli array devono essere allocati in fase di compilazione (con alcune eccezioni specifiche del compilatore). Se vuoi essere in grado di modificare facilmente la dimensione dell’array x in fase di compilazione , puoi farlo:

  #define SIZE 100 float x[SIZE][2]; 

Se si desidera realmente allocare l’array in base alle informazioni che si hanno solo in fase di esecuzione, è necessario allocare l’array in modo dinamico con malloc o new .

È una restrizione della lingua. Le dimensioni delle matrici devono essere espressioni costanti. Ecco un parziale jsutification da cplusplus.com

NOTA: il campo di elementi tra parentesi [] che rappresenta il numero di elementi che l’array deve contenere, deve essere un valore costante, poiché gli array sono blocchi di memoria non dynamic la cui dimensione deve essere determinata prima dell’esecuzione. Per creare array con una memoria dynamic di lunghezza variabile è necessario, come spiegato più avanti in queste esercitazioni.

La dimensione di un array automatico deve essere una costante in fase di compilazione.

  const int size = 100; float x[size][2]; 

Se la dimensione non era nota in fase di compilazione (ad esempio, inserita dall’utente, determinata dal contenuto del file), è necessario utilizzare l’allocazione dynamic, ad esempio:

 std::vector > x(somesize); 

(Invece di una coppia, una struttura / class Point dedicata avrebbe perfettamente senso).

Perché si aspettava un’espressione costante!

Le dimensioni della matrice in C (ignorando i VLA di C99) e C ++ devono essere conosciute in fase di compilazione. Ciò non significa solo etichettato con const : devono essere hard-coded nel programma.

Utilizzare l’allocazione dynamic o std::vector (che è un wrapper attorno all’allocazione dell’array dinamico) per determinare le dimensioni dell’array in fase di esecuzione.

Non hai assegnato alcun valore alle dimensioni; quindi il compilatore non può allocare la memoria per l’array. (Un array di dimensioni nulle? Cosa?)

Inoltre, dovresti rendere SIZE una costante e non una variabile.

EDIT: Purtroppo, questa risposta non ha più senso dal momento che il poster ha cambiato la sua domanda.