C++ devrait expression constante

#include <iostream>
#include <fstream>
#include <cmath>
#include <math.h>
#include <iomanip>
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<size) {



points>>(x[count][0]);
//cout<<"x= "<<(x[count][0])<<"  ";//read in x value
points>>(x[count][1]);
//cout<<"y= "<<(x[count][1])<<endl;//read in y value


count++;
}

Ce programme m'attend expression constante d'erreur sur la ligne où je déclare float x[taille][2]. Pourquoi?

OriginalL'auteur n0ob | 2010-03-15

arrays c++constant-expression

12
```
float x[size][2];
```
Qui ne fonctionne pas parce déclaré que les tableaux peuvent pas avoir d'exécution tailles. Essayez un vecteur:
```
std::vector< std::array<float, 2> > x(size);
```
Ou de l'utilisation de nouvelles
```
//identity<float[2]>::type *px = new float[size][2];
float (*px)[2] = new float[size][2];

//... use and then delete
delete[] px;
```
Si vous n'avez pas de C++11 est disponible, vous pouvez utiliser boost::array au lieu de std::array.

Si vous n'avez pas de boost, faites votre propre type de tableau que vous pouvez coller dans le vecteur
```
template<typename T, size_t N>
struct array {
  T data[N];
  T &operator[](ptrdiff_t i) { return data[i]; }
  T const &operator[](ptrdiff_t i) const { return data[i]; }
};
```
Pour alléger la syntaxe de new, vous pouvez utiliser un identity modèle qui est une définition de type (aussi disponible en boost)
```
template<typename T> 
struct identity {
  typedef T type;
};
```
Si vous le souhaitez, vous pouvez également utiliser un vecteur de std::pair<float, float>
```
std::vector< std::pair<float, float> > x(size);
//syntax: x[i].first, x[i].second
```
OriginalL'auteur Johannes Schaub - litb
8

Le tableau sera attribué au moment de la compilation, et depuis size n'est pas une constante, le compilateur ne peut pas déterminer avec précision sa valeur.

OriginalL'auteur Justin Ethier
4

Vous ne pouvez pas avoir de la longueur variable des tableaux (comme ils sont appelés dans le C99) en C++. Vous avez besoin d'utiliser des tableaux alloués dynamiquement (si la taille varie) ou statique intégrale de l'expression constante de la taille.

OriginalL'auteur dirkgently
2

La ligne float x[size][2] ne fonctionne pas, car les tableaux doivent être attribués au moment de la compilation (avec un peu de compilateur exceptions spécifiques). Si vous voulez être en mesure de facilement changer la taille de la matrice x à compiler temps, vous pouvez faire ceci:
```
 #define SIZE 100
 float x[SIZE][2];
```
Si vous voulez vraiment allouer le tableau basé sur les informations vous avez seulement au moment de l'exécution, vous devez allouer le tableau dynamiquement avec malloc ou new.

OriginalL'auteur JSBձոգչ
1

C'est une restriction de la langue. La taille des matrices doivent être des expressions constantes. Voici une partielle jsutification de cplusplus.com

REMARQUE: Les éléments de champ à l'intérieur de crochets [], qui représente le nombre d'éléments du tableau va contenir, doit être une valeur constante, comme les tableaux sont des blocs de non-dynamique de la mémoire dont la taille doit être déterminée avant l'exécution. Afin de créer des tableaux avec une longueur variable de la mémoire dynamique est nécessaire, ce qui est expliqué plus loin dans ces tutoriels.

OriginalL'auteur JaredPar
1

La taille automatique d'un tableau doit être une constante de compilation.
```
 const int size = 100;
 float x[size][2];
```
Si la taille n'étaient pas connues au moment de la compilation (e.g entré par l'utilisateur, déterminé à partir du contenu du fichier), vous devez utiliser l'allocation dynamique, par exemple:
```
std::vector<std::pair<float, float> > x(somesize);
```
(Au lieu d'une paire, une struct/classe serait parfaitement logique.)

OriginalL'auteur UncleBens
1

Car elle attend une expression constante!

Dimensions du tableau en C (en ignorant le C99 est VLAs) et C++ doivent être les quantités connues au moment de la compilation. Cela ne signifie pas seulement une étiquette avec const: ils ont à être codées en dur dans le programme.

Utiliser l'allocation dynamique ou std::vector (qui est un wrapper autour de la dynamique de l'allocation de tableau) pour déterminer la taille des matrices au moment de l'exécution.

OriginalL'auteur Lightness Races in Orbit
1

Vous n'avez pas affecté de la valeur à la taille; ainsi, le compilateur ne peut pas allouer de la mémoire pour le tableau. (Un tableau de taille nulle? Quoi?)

En outre, vous aurez besoin de faire une TAILLE constante, et non une variable.

EDIT: Malheureusement, cette réponse n'a plus de sens depuis que l'affiche a changé leur question.

OriginalL'auteur mszaro

Vous devez vous connecter pour publier un commentaire.