Variable length arrays depending on length of file C++ - c++

Question

I'm encountering a problem trying to generalize my algorithm for any-size problems.
The code is working for the test problem I used, but I had to insert manually the lenght of some arrays. Next, I've tried reading the lenght of input files in two variables, but then I'm not able to use them in all of my code, but just in some pieces. I think it's quite a stupid thing, but I'm really new to C++ and I'd like to get help.
Here's the piece of code:
#include <fstream>
#include <iostream>
#include <time.h>
using namespace std;
struct node{
int last_prod;
int last_slot;
float ZL;
float ZU;
float g;
bool fathomed;
node *next;
node *padre;
node *primofiglio;
};
clock_t start, end;
double cpu_time_used;
int l=0;
int cont_slot=0;
int cont_prod=0;
float temp_cont;
float distanze[360]; // dichiarazione variabili
int slot[111];
int slot_cum[111];
float COIp[111];
int domanda[111];
float Zb=9999999999999999;
float LowerBound(struct node *n);
float UpperBound(struct node *n);
float h(struct node *l,struct node *n);
void creasottolivello(struct node *n);
void fathRule2(struct node *n);
void fathRule3(struct node *n);
void stampaRisultati(struct node *n, ofstream &f);
int unFathomedNodes(struct node *n);
void append(struct node* temp, struct node* n);
void ricercaOttimo(struct node *n, ofstream &f);
void calcoloBounds(struct node *n);
int main(){
start = clock();
ifstream contdist_file ( "/Users/MarcoBi/Desktop/TESI di LAUREA/Xcode/dati/distanze.txt" ); // conteggio dati input
if ( !contdist_file.is_open() ) { //conta righe file slot
}
else {
for(int i=0; !contdist_file.eof(); i++){
contdist_file >> temp_cont;
cont_slot++;
}
}
ifstream contslot_file ( "/Users/MarcoBi/Desktop/TESI di LAUREA/Xcode/dati/slot.txt" );
if ( !contslot_file.is_open() ) { //conta righe file prodotti
}
else {
for(int i=0; !contslot_file.eof(); i++){
contslot_file >> temp_cont;
cont_prod++;
}
}
....
As you can see, in the main() I count the lenght of input files into cont_prod and cont_slot variables, but then I can't use them in variable declaration. The variable lenght arrays I need have to be global variables 'cuz I need them also in other functions. And also cont_prod and cont_slot need to be global, as I need them in local variable declarations in some functions.
Here is one of the functions I need to use them in:
float LowerBound(struct node *n){ //funzione LowerBound
int S[111];
int Sp=0;
float d[111];
float dmin[111];
float D;
float LB;
for(int i=n->last_prod;i<111;i++){
Sp=Sp+slot[i];
}
for(int i=0;i<111;i++){ //Calcolo S_pigreco
S[i]=0;
}
if(n->last_prod==0){ //condizione necessaria per nodo radice
S[0]=slot[0];
for(int i=n->last_prod +2;i<111;i++){
for(int j=n->last_prod +1;j<=i;j++){
S[j]=S[j-1]+slot[j];
}
}
}
else{
for(int i=n->last_prod +1;i<111;i++){
for(int j=n->last_prod;j<=i;j++){
S[j]=S[j-1]+slot[j];
}
}
}
S[110]=S[109] + slot[110];
//calcolo somma distanze da slot j+1 a q
for(int i=0;i<111;i++){
d[i]=0;
}
for(int j=n->last_prod;j<111;j++){
for(int i=n->last_slot; i < n->last_slot +S[j]; i++){
d[j]=d[j]+distanze[i];
}
}
//calcolo dmin_pigreco
for(int i=n->last_prod; i<111; i++){
dmin[i]= d[i]/S[i];
}
D=0;
for(int i=n->last_prod; i<111; i++){
D=D+dmin[i]*domanda[i];
}
LB=n->g+2*D;
return LB;
}
111 is cont_prod and 360 is cont_slot.
I'm programming on a Mac in Xcode and it says that variable lenght arrays cannot be declared at file scope, which I think it means as global variables.
How can I manage that?

Answer 1

Just focusing on your actual question here: in C++, you create variable length-arrays using std::vector, like this:
std::vector<char> myCharArray( n * 1000 );
You can then use the expression
&myCharArray[0]
to use the vector object in all cases where you'd normally pass a raw C array.

Answer 2

Perhaps declare pointers at file scope and allocate memory dynamically as and when you know the values...
Declare
int *slot
and allocate memory as
slot = new int[cont_slot];
and after using dont forget to "delete [] slot" it .. :)

Answer 3

Disclaimer: I didn't read the whole question, but it seems to me like you need either a dynamically allocated array:
float* distanze = new float[length];
or, better yet, a std::vector:
std::vector<float> distanze; // <-- this is the proper C++ way
You can insert values in the vector via distanze.push_back(float) and iterate through it just like it was an array, with operator [].

Answer 4

For starters, you should learn to format your code.
Secondly, in C++, an array is normally declared with something like:
std::vector<float> anArray;
The declaraion using a [] is a left-over from C, and is only used in
very special cases (once you've fully mastered std::vector). And a
vector will extend itself automatically if you use push_back to insert
values. And an std::vector carries its size around with it, so you
can iterator using:
for ( int i = 0; i != v.size(); ++ i ) {
// use `v[i]` here...
}
You can also iterate using iterators, which is more idiomatic in general
(but perhaps not in the case where you are doing numerical work).
Finally, std::istream::eof() is really only useful once input has
failed (to know whether the failure is due to end of file, or something
else). The usual idiom to read would be something like:
float value;
while ( contdist_file >> value ) {
distanze.push_back( value );
}
(I'm supposing that this is what you actually want in the first loop.
In the code you've posted, you just read into a temporary variable,
overwriting each time, but not otherwise doing anything with the value
you read.)
Finally, unless your vectors may be very large, it's usual to use
double in C++, rather than float. (But this depends on the
total amount of data you need to handle, as well as the precision you
need.) Note too that a loop with:
Sp += slot[i];
will likely give very poor results if the size of slot is large,
unless you're lucky with the values in slot. If the values are in the
range of 0.5...1, for example, after a couple of thousand values, with
float, you only have about 3 or 4 decimal digits of precision, and if
the first value happens to be 10000000, any following values less than 1
are treated as zero. Typically, you need special algorithms to sum up
floating point sequences. (Using double will improve things, but not
eliminate the problem.)