[C++]Problema operator[]

[Luc@s]

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?

[TheGreatWorld]

Puoi precisare che errore ottieni e su che piattaforma? intanto ti dico che questo code gira perfettamente:

#include <iostream>

class vec
{

	char		*str;
	unsigned long	dim;

	public:

	vec(const char *);
	~vec(void);
	char& operator[](const unsigned long);
	char* operator()(void);

};


vec::vec(const char *p)
{

	unsigned long	c(0);
	while (p[c++]);

	str = new char[c + 1];
	str[c] = '\0';

	for (c = 0; p[c]; str[c] = p[c++]);

	dim = c;
}

vec::~vec()
{

	delete[] str;

}

char& vec::operator[](const unsigned long c)
{

	if ((c >= 0) && (c < dim))
		return str[c];

	return str[dim];

}

char* vec::operator()()
{

	return str;
}

int main()
{

	vec a("dust");
	std::cout << a() << std::endl;

}

Bye bye

[Luc@s]

Sono su Winxp e compilo con DevC++ 4.80.
Ecco il cod:

 // 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[](int index);
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[]( int index )
{
    if( (index <= dimensione) && (index > 0) )
    return elementi[index];
}

Ed ecco gli errori:

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

[TheGreatWorld]

Come ho già detto in un altro post se vuoi utilizzare questo tipo di modularizzazione devi necessariamente esportare il template. In pratica la definizione del template deve essere asportata se si trova in una unità di compilazione diversa rispetto la dichiarazione. Fai cosi:

// 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[](int index);
private:
	T* elementi; // gli elementi
	int dimensione; // la dimensione

};
#endif

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

/**
 Construttore standard(1 arg)
*/
export 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
*/
export template<class T>
Vettore<T>::~Vettore()
{
	delete[] elementi;
}

/**
 Restituisce la dimensione
*/
export template<class T>
int Vettore<T>::getDimensione()
{
	return dimensione;
}
/**
 Ordina gli elementi
*/
export 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
*/
export 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)
*/
export 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)
*/
export 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)
*/
export template<class T>
T Vettore<T>::getElemento(int pos)
{
	return elementi[pos];
}

/**
 Rimuove un elemento (con posizione specificata)
*/
export template<class T>
void Vettore<T>::RimuoviElemento(int pos)
{
	if( (pos < dimensione) && (pos >= 0) )
	elementi[pos] = NULL;
}
/**
 Ridimensiona l'array
*/
export 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
*/
export template<class T>
void Vettore<T>::Svuota()
{   
}
/**
 Overloading del subscript
*/
export int& Vettore<T>::operator[]( int index )
{
    if( (index <= dimensione) && (index > 0) )
    return elementi[index];
}

Oltretutto per l'operatore che hai overloadato non hai esplicitato il template nella definizione. Non ho notato se ci sono altri errori sintattici, ma cosi dovrebbe andare.

bye

[Luc@s]

ho risolto cosi:

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

Tnk cmq per l'aiuto!
Faccio pena vero??
Mi dovrei ritirare secondo te?

[TheGreatWorld]

Beh se non te ne sei accorto è la stessa variazione che ti ho proposto io con l'aggiunta di export che devi inserire necessariamente. Tutti hanno sempre qualcosa da studiare, l'importante e' fare qualcosa che ci piace con l'umilta' di chi sa che ha sempre da imparare qualcosa dagli altri.

bye

[Luc@s]

Originariamente inviato da TheGreatWorld
Beh se non te ne sei accorto è la stessa variazione che ti ho proposto io con l'aggiunta di export che devi inserire necessariamente. Tutti hanno sempre qualcosa da studiare, l'importante e' fare qualcosa che ci piace con l'umilta' di chi sa che ha sempre da imparare qualcosa dagli altri.

bye

e che nn sono sicuro che export sia ancora ANSI/ISO...........io le librerie le voglio fare portabili al 100%

[TheGreatWorld]

Certo che lo e'!! come daltronde tutto il codice che ho postato in questo forum...

bye

[r0x]

L`errore stava nel fatto che invece di 'Vettore< T >::' metteva 'Vettore::'. Inoltre:

if( (index <= dimensione) )

Ancora bisogna vedere queste cose?

[Luc@s]

Originariamente inviato da r0x
L`errore stava nel fatto che invece di 'Vettore< T >::' metteva 'Vettore::'. Inoltre:

if( (index <= dimensione) )

Ancora bisogna vedere queste cose?

mi do all'ippica