[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

[verloc]

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

come non detto