C++ expected constant expression

问题:

#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>(x[count][0]); //cout>(x[count][1]); //cout

This program is giving me expected constant expression error on the line where I declare float x[size][2]. Why?

回答1:

float x[size][2]; 

That doesn't work because declared arrays can't have runtime sizes. Try a vector:

std::vector > x(size); 

Or use new

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

---

If you don't have C++11 available, you can use boost::array instead of std::array.

If you don't have boost available, make your own array type you can stick into vector

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

For easing the syntax of new, you can use an identity template which effectively is an in-place typedef (also available in boost)

template  struct identity {   typedef T type; }; 

---

If you want, you can also use a vector of std::pair

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

回答2:

The array will be allocated at compile time, and since size is not a constant, the compiler cannot accurately determine its value.

回答3:

You cannot have variable length arrays (as they are called in C99) in C++. You need to use dynamically allocated arrays (if the size varies) or a static integral constant expression for size.

回答4:

The line float x[size][2] won't work, because arrays have to be allocated at compile time (with a few compiler-specific exceptions). If you want to be able to easily change the size of the array x at compile time, you can do this:

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

If you really want to allocate the array based on information you only have at runtime, you need to allocate the array dynamically with malloc or new.

回答5:

It is a restriction of the language. Array sizes must be constant expressions. Here's a partial jsutification from cplusplus.com

NOTE: The elements field within brackets [] which represents the number of elements the array is going to hold, must be a constant value, since arrays are blocks of non-dynamic memory whose size must be determined before execution. In order to create arrays with a variable length dynamic memory is needed, which is explained later in these tutorials.

回答6:

The size of an automatic array must be a compile-time constant.

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

If the size weren't known at compile-time (e.g entered by the user, determined from the contents of the file), you'd need to use dynamic allocation, for example:

std::vector<:pair float=""> > x(somesize); 

(Instead of a pair, a dedicated Point struct/class would make perfect sense.)

回答7:

Because it expected a constant expression!

Array dimensions in C (ignoring C99's VLAs) and C++ must be quantities known at compile-time. That doesn't mean just labelled with const: they have to be hard-coded into the program.

Use dynamic allocation or std::vector (which is a wrapper around dynamic array allocation) to determine array sizes at run-time.

回答8:

You haven't assigned any value to size; thus the compiler cannot allocate the memory for the array. (An array of null size? What?)

Additionally, you'd need to make SIZE a constant, and not a variable.

EDIT: Unfortunately, this response no longer makes sense since the poster has changed their question.

文章来源: C++ expected constant expression