[C++]Problema operator[]

[Kleidemos]

Ho questo overloading:

//altro

///////////////////////////////
// Overloading
///////////////////////////////
int &operator[](int index);
//altro


Cosi implementato:

/**
Overloading del subscript
*/
int &Vettore::operator[]( int index )
{
if( (index <= dimensione) && (index > 0) )
return elementi[index];
}


Ma mi da errore nei :: dell'implementazione............................
.......perche?

[ri]

non capisco il & a che ti serve... (e non so neanche se si può fare)

[cionci]

Qaule errore ti ha dato ?

[Kleidemos]

Originally posted by "cionci"

Qaule errore ti ha dato ?


Compilatore: Default compiler
Building Makefile: "C:\Progetti\Vettore\Makefile.win"
Esecuzione di make...
make.exe -f "C:\Progetti\Vettore\Makefile.win" all
g++.exe -c Src/Vettore.cpp -o Src/Vettore.o -I"C:/Dev-Cpp/include/c++" -I"C:/Dev-Cpp/include/c++/mingw32" -I"C:/Dev-Cpp/include/c++/backward" -I"C:/Dev-Cpp/include"

Src/Vettore.cpp:142: syntax error before `::' token

make.exe: *** [Src/Vettore.o] Error 1

Esecuzione terminata

[cionci]

Non è che l'errore è in qualche linea precedente ?

[Kleidemos]

Originally posted by "cionci"

Non è che l'errore è in qualche linea precedente ?

no perche il resto è testato ;)

[verloc]

Non so se centri,ma in genere non si usa int per l'indice ma
unsigned int.
Probabilmente se la classe fa rifarimento ad un array è questo l'errore.
Se no potresti scrivere array[-3] non ti pare?
Può darsi che mi sbagli.
Poi: perchè index > 0 ?
Prova.

[Kleidemos]

Originally posted by "verloc"

Non so se centri,ma in genere non si usa int per l'indice ma
unsigned int.
Probabilmente se la classe fa rifarimento ad un array è questo l'errore.
Se no potresti scrivere array[-3] non ti pare?
Può darsi che mi sbagli.
Poi: perchè index > 0 ?
Prova.

ops :>=

[/\/\@®¢Ø]

Originally posted by "Kleidemos"

Ho questo overloading:

//altro

///////////////////////////////
// Overloading
///////////////////////////////
int &operator[](int index);
//altro


Cosi implementato:

/**
Overloading del subscript
*/
int &Vettore::operator[]( int index )
{
if( (index <= dimensione) && (index > 0) )
return elementi[index];
}


Ma mi da errore nei :: dell'implementazione............................
.......perche?

Probabilmente ti sei dimenticato di includere la dichiarazione della classe nel file dell'implementazione e quindi il compilatore non capisce cosa sia Vettore. Come ha fatto notare verloc se usi un unsigned int e' piu' corretto e ti risparmi un controllo.
Dovresti avere i sorgenti organizzati piu' o meno cosi':


// Vettore.h
#ifndef VETTORE_H
#define VETTORE_H
class Vettore{
/* ... */
int& operator[](unsigned int);
};
/*...*/
#endif


e

// Vettore.cpp
#include "Vettore.h"
int& Vettore::operator[](unsigned int x){ /*...*/ }


Se il problema non e' questo, probabilmente l'errore e' in realta' nella dichiarazione/definizione precedente (ad esempio hai dimenticato di chiudere la linea con il ';' )

[Kleidemos]

mi da sempre lo stesso errore:(:(

[/\/\@®¢Ø]

Ah... trovato un errore intanto: se l'indice non e' compreso nell'intervallo, che ritorni ? Dovresti lanciare un'eccezione, ad esempio

struct Error {} ;

int& Vector::operator[]( int n )
{
if ( n < 0 || n >= dimensione )
throw Error();
return elementi[index];
}

Oppure non fai del tutto il controllo (e lo deleghi a chi usa la classe)

se ancora non va (probabilmente no visto che l'errore era segnalato prima ) prova a postare tutto il file cpp allora..

[Kleidemos]

// Vettore.h: interface for the Vettore class.

#ifndef VETTORE_H
#define VETTORE_H
#include <cstring>
#include <cstdio>

template<class T>
/**
La classe del vettore
*/
class Vettore
{
public:
///////////////////////////////
// Costruttori/distruttori
///////////////////////////////
Vettore(int dim=10);
~Vettore();
///////////////////////////////
// Utilita di ricerca
///////////////////////////////
void Ordina();
int cerca(T key);
///////////////////////////////
// Funzioni di interfaccia
///////////////////////////////
int getDimensione();
T getElemento(int pos);
void Stampa();// TODO
///////////////////////////////
// Funzioni vettore
///////////////////////////////
void AggiungiElemento(T elemento, int pos);
void AggiungiElemento(T elemento);
void RimuoviElemento(int pos);
void Ridimensiona(int new_dim);
void Svuota();
///////////////////////////////
// Overloading
///////////////////////////////
int& operator[](unsigned int);
private:
T* elementi; // gli elementi
int dimensione; // la dimensione

};
#endif
// Vettore.cpp

#include "Vettore.h"
#include <cstring>
#include <string>
#include <cmath>

/**
Construttore standard(1 arg)
*/
template<class T>
Vettore<T>::Vettore(int dim)
{
dimensione = dim;
elementi = new T[dimensione];
for(int i=0;i<dimensione;i++)
{
elementi[i] = NULL;
}

}

/**
Distruttore standard
*/
template<class T>
Vettore<T>::~Vettore()
{
delete[] elementi;
}

/**
Restituisce la dimensione
*/
template<class T>
int Vettore<T>::getDimensione()
{
return dimensione;
}
/**
Ordina gli elementi
*/
template<class T>
void Vettore<T>::Ordina()
{
bool is_sorted=false;
int p=0,q=0;
T tmp;// la variabile temporanea di appoggio
while(!is_sorted){
is_sorted=true;
++p;// p viene avanzato e poi visualizzato
for(q=0;q<dimensione-p;++q){
if(elementi[q]>elementi[q+1])
{
tmp=elementi[q];
elementi[q]=elementi[q+1];
elementi[q+1]=tmp;
is_sorted=false;// esce dal for
}
}
}
}
/**
Ricerca elementi
*/
template<class T>
int Vettore<T>::cerca(T key)
{
for(int i=0;i<dimensione;i++)
{
if(elementi[i] == key)
return i;
}

return -1;
}
/**
Aggiunge un elemento (con posizione specificata)
*/
template<class T>
void Vettore<T>::AggiungiElemento(T elemento, int pos)
{
if( (pos < dimensione) && (pos >= 0) )
elementi[pos] = elemento;
}

/**
Aggiunge un elemento (senza posizione specificata)
*/
template<class T>
void Vettore<T>::AggiungiElemento(T elemento)
{
for(int pass=0;pass<dimensione;pass++)
{
if(elementi[pass] == NULL)
elementi[pass] = elemento;
break; // esce dal for
}
}
/**
Restituisce un elemento (posizione specificata)
*/
template<class T>
T Vettore<T>::getElemento(int pos)
{
return elementi[pos];
}

/**
Rimuove un elemento (con posizione specificata)
*/
template<class T>
void Vettore<T>::RimuoviElemento(int pos)
{
if( (pos < dimensione) && (pos >= 0) )
elementi[pos] = NULL;
}
/**
Ridimensiona l'array
*/
template<class T>
void Vettore<T>::Ridimensiona(int new_dim)
{
T *tmp = new T[new_dim];
for(int j=0;j<getDimensione();j++)
{
tmp[j] = elementi[j];
}
dimensione = new_dim;
elementi = tmp;
}
/**
Svuota e reimposta a 0 tutti gli elementi
*/
template<class T>
void Vettore<T>::Svuota()
{
}
/**
Overloading del subscript
*/
int& Vettore::operator[](unsigned int x)
{
if( (index <= dimensione) )
return elementi[index];
}

[/\/\@®¢Ø]

aaah, ma e' un template...

allora hai dimenticato il <T> (e devi ritornare un T)

template <class T>
T& Vettore<T>::operator[]( int n ) { /*...*/ }

[Kleidemos]

Originally posted by "/\/\@®¢Ø"

aaah, ma e' un template...

allora hai dimenticato il <T> (e devi ritornare un T)

template <class T>
T& Vettore<T>::operator[]( int n ) { /*...*/ }

hai ragione!
Cazzo................faccio pena :cry:

[verloc]

Stavo appunto per drirgli che solitamente una classe array
si fa con un template...

come non detto :)