C++ expected constant expression

#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++;
}

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

float x[size][2];

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

std::vector< std::array<float, 2> > x(size);

Or use new

// identity<float[2]>::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<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]; }
};

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

template<typename T> 
struct identity {
  typedef T type;
};

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

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

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

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.

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.

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<std::pair<float, float> > x(somesize);

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

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.

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.

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.