C++

Forum

 
List of sliders with template

Pages: 12
Giuggiola (26)
this line of code..
typedef typename ListaCur<T>::template ComponenteSpazio<T> static *SPAZIO;

..generates this error:
[Error] conflicting specifiers in declaration of 'SPAZIO'


I tried to replace 'static' with 'extern', but the result is the same.

Moreover,

typename ListaCur<T>::ComponenteSpazio<T> *ListaCur<T>::inizializza(){

..generates this error:
[Error] non-template 'ComponenteSpazio' used as template

//this line of code..
template<class T>
typename ListaCur<T>::ComponenteSpazio<T> *ListaCur<T>::SPAZIO = ListaCur<T>::inizializza();

//..generates this error:
[Error] expected unqualified-id before ';' token

template<class T>
void ListaCur<T>::create(){//creaLista(){

lista=listalibera;
SPAZIO[lista].precedente=lista;
SPAZIO[lista].successivo=lista;
listalibera=SPAZIO[listalibera].successivo;
cout << "lista creata"<< endl;
primo = NIL;
lunghezza = 0;
primoVuoto = 0;
}

//..generates this error:
In member function 'void ListaCur<T>::create()':
[Error] 'SPAZIO' was not declared in this scope

Can anyone help me figure out where I'm wrong? thanks
Gamer2015 (810)
why would you use static or extern in the first place, this is a typedef not a variable.
Giuggiola (26)
without 'typedef' errors become 18 and not more than 10
Giuggiola (26)
removing 'static' errors become 15
Giuggiola (26)
I want to declare an array 'space' type 'ComponenteSpazio' to be 'static' because it contains lists and the 'free list' in the section 'private' of ListaCur <T>
Gamer2015 (810)
you should only use english for your code, I don't have an Idea of what your variables mean (which could help)

try it without the keyword template in the middle and without static:
typedef typename ListaCur<T>::template ComponenteSpazio<T> static *SPAZIO;
Last edited on
Giuggiola (26)
typedef typename ListCURSORS<T>::ComponentSpace<T> *SPACE;

//..generates this error:
[Error] expected unqualified-id before '<' token

Gamer2015 (810)
this is getting complicated.
Please post your class decleration from ListCursors and ComponentSpace and where you have that typedef.

note: you might need to remove that asterix before spazio.
Last edited on
Giuggiola (26)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
#ifndef LISTACUR_H
#define LISTACUR_H
#include "Nodo.h"
#include "NodoCur.h"

#include <iostream>
#include <cstdlib>
#include <stdlib.h>

using namespace std;
const int MAXLUNG=100;

//#define MAXLUNG 100

template<class T>
class ListaCur : public Linear_list<T, int>{
//	typedef typename ListaCur<T>::template ComponenteSpazio<T>  *SPAZIO;
public:
	 
   typedef typename Linear_list<T, int>::value_type value_type;
   typedef typename Linear_list<T, int>::position position;
		
   ListaCur(); // costruttore
   ~ListaCur(); // distruttore
   
   void create(); //void creaLista();
   bool empty() const; //bool listaVuota();
   position begin() const; //posizione primoLista();
   position previous(position) const;//   position predLista(position);

   
private:   
   typedef typename ListaCur<T>::ComponenteSpazio<T> SPAZIO; 

   void spostaNodo(position &, position &);
  
   static position listalibera;
   position lista;
   static bool inizializzato;

   static ComponenteSpazio<T> * inizializza();
   position primo;
   position primoVuoto;
   int lunghezza;
};
//#endif

template<class T>                     //<T>
typename ListaCur<T>::ComponenteSpazio<T> *ListaCur<T>::inizializza(){
	//                           <T>
	SPAZIO = new ComponenteSpazio<T>[MAXLUNG];
    if (!inizializzato){
	  SPAZIO[0].precedente= MAXLUNG-1;
	  SPAZIO[0].successivo= 1;
	  for (int i=1;i<MAXLUNG;i++){
	     SPAZIO[i].precedente=(i-1)%MAXLUNG;
		 SPAZIO[i].successivo=(i+1)%MAXLUNG;
      }
	  inizializzato=true;
	  cout << "spazio inizializzato" << endl;
	  return(SPAZIO);
   }
}

template<class T>                    
typename ListaCur<T>::ComponenteSpazio<T> *ListaCur<T>::SPAZIO = ListaCur<T>::inizializza();

template<class T>
typename ListaCur<T>::position ListaCur<T>::listalibera = 0;

template <class T> //INIZIALIZZATO
bool ListaCur<T>::inizializzato=false;

template<class T>
ListaCur<T>::ListaCur(){
	cout<<"ListaCur()"<<endl;
   create();//creaLista();
}
         	              
template<class T>   
void ListaCur<T>::create(){//creaLista(){

   lista=listalibera;
   SPAZIO[lista].precedente=lista;
   SPAZIO[lista].successivo=lista;
   listalibera=SPAZIO[listalibera].successivo;
   cout << "lista creata"<< endl;
   primo = NIL;
   lunghezza = 0;
   primoVuoto = 0;   
}

template<class T>
ListaCur<T>::~ListaCur(){
	listalibera=lista;
	cout<<"lista cancellata"<<endl;
} 
  
template<class T>
bool ListaCur<T>::empty() const{ //bool empty() const
   return (lunghezza == 0);
}

template<class T>
typename ListaCur<T>::position ListaCur<T>::begin() const {
   return primo;
}
  
template<class T> 
typename ListaCur<T>::position ListaCur<T>::previous(position p) const {
	
   position temp = primo;
   // while (SPAZIO[temp].getSuccessivo() != p)
   while (SPAZIO[temp].getSuccessivo() != p)
      temp = SPAZIO[temp].getSuccessivo(); //temp = SPAZIO[temp].getSuccessivo();
   return temp;
}
#endif
Giuggiola (26)
I know that the code is not in English, but I have to hurry as it was published
Gamer2015 (810)
In this context: what is ComponenteSpazio?

typedef typename ListaCur<T>::ComponenteSpazio<T> SPAZIO;
It looks like it is a nested class in ListaCur but there is no nested class?

Giuggiola (26)
ComponenteSpazio<T> = ComponentSpace<T>

'ComponenteSpazio' is not a nested class, 'ListaCur' should be related to aggregation, ComponenteSpazio I defined in another file 'NodoCur.h'. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
#include <cstdlib>
#include <iostream>
#ifndef _SPAZIO_H
#define _SPAZIO_H

#include "linear_list.h" 

#include "Nodo.h"
#define NIL -1

template<class T>
class ComponenteSpazio : public Nodo<T>{
 public:
 
   typedef typename Linear_list<T, int>::value_type value_type;
  typedef typename Linear_list<T, int>::position position;
   ComponenteSpazio();
   ComponenteSpazio(value_type);  // costruttore che inizializza l'etichetta
   ComponenteSpazio(value_type, position); // etichetta + cursore
   ~ComponenteSpazio();
   
   position getSuccessivo();
   void setSuccessivo(position);
   
 private:

	position successivo;
	  position precedente;
};

template<class T> 
ComponenteSpazio<T>::ComponenteSpazio(): Nodo<T>(0){ //
   successivo = NIL; // posizione vettore non valida
}

template<class T> 
ComponenteSpazio<T>::ComponenteSpazio(value_type a): Nodo<T>(a){ //<T>
   successivo = NIL; // IDEM come sopra
}

template<class T> 
ComponenteSpazio<T>::ComponenteSpazio(value_type a, position p): Nodo<T>(a){ //<T>
   successivo = p;
}

template<class T> 
ComponenteSpazio<T>::~ComponenteSpazio(){};

template<class T>                             
typename ComponenteSpazio<T>::position ComponenteSpazio<T>::getSuccessivo(){
   return successivo;
}

template<class T>  
void ComponenteSpazio<T>::setSuccessivo(position p){
   successivo = p;     
}

#endif // _SPAZIO_H



'Space Component' extends class 'Knot' defined in the following file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
#ifndef NODO_H
#define NODO_H
#include "linear_list.h"
#include <iostream>

#include <cstdlib>
//typedef int tipoelem;
template<class T>
class Nodo : public Linear_list<T, int>{
 public:
 //  typedef typename ListaCur<T>::value_type value_type;
 //  typedef typename ListaCur<T>::position position;	
   
    typedef typename Linear_list<T, int>::value_type value_type;
   typedef typename Linear_list<T, int>::position position;	
 	
   Nodo(); // costruttore standard
   Nodo(value_type);  // costruttore che inizializza l'etichetta
   ~Nodo(); // distruttore
   
   value_type getEtichetta();
   void setEtichetta(value_type);
   
 private://tipoelem elem;
   value_type etichetta;
};

template<class T> 
Nodo<T>::Nodo(){
   etichetta = 0;
}

template<class T>
Nodo<T>::Nodo(value_type a){
   etichetta = a;
}

template<class T> 
Nodo<T>::~Nodo(){}

template<class T>        
typename Nodo<T>::value_type Nodo<T>::getEtichetta(){
   return etichetta;
}

template<class T> 
void Nodo<T>::setEtichetta(value_type a){
   etichetta = a;     
}

#endif
Gamer2015 (810)
Okey then you should emit that ListaCur<T>::
typedef typename ListaCur<T>::ComponenteSpazio<T> SPAZIO;

typedef typename ComponenteSpazio<T> SPAZIO;

I'm not sure about the typename, if it does not work remove the typename as well and then show the results.
Last edited on
Giuggiola (26)
ok I'm translating the code
Giuggiola (26)
Thanks! now I try
Giuggiola (26)
ListaCur<T>::typedef ComponenteSpazio<T> SPAZIO;

that line produces the error:

[Error] expected unqualified-id before 'typedef'

because he said 'ComponenteSpazio' is not a template ?:
[Error] non-template 'ComponenteSpazio' used as template

if 'ComponenteSpazio' is a template?
Giuggiola (26)
the professor told me that the class 'Knot' must extend the virtual Linear_List, although 'ListaCur' extends well 'Linear_List'. Perhaps the problem is dependent on this?Or maybe I misunderstood me?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
#ifndef _LISTALIN_H
#define _LISTALIN_H

#include <iostream>

using std::cout;
using std::endl;
using std::ostream;

// classe astratta listaLineare
template< class T, class P >
class Linear_list{
 public:
	typedef T value_type;   // the type of object, T, stored in the list
	typedef P position;
	
	// operators
	virtual void create() = 0;
//	virtual bool empty() const = 0; // true if the list's size is 0
//	virtual value_type read(position) const = 0;
//	virtual void write(const value_type & x, position p) = 0; // write x at position p
//	virtual position begin() const = 0;  // returns a position pointing to the beginning of the list
//	virtual bool end(position) const = 0; // returns a position pointing to the end of the list
//	virtual position next(position) const = 0; // returns the next position
//	virtual position previous(position) const = 0; // return the previous position
//	virtual void insert(const value_type &, position) = 0; // insert an element 
//	virtual void erase(position pos) = 0; // ersaes the element at position pos
  //  virtual void clear()=0; // erases all the elements
  //  virtual int size() const = 0;  // returns the size of the list
 //   virtual  ~Linear_list() {};
};

/* sovraccarica <<. Attenzione se il tipo restituito da read non è primitivo, allora
 * anche per questo tipo bisogna sovraccaricare l'operatore << 
 */
template< class T, class P >
ostream& operator<<(ostream& os, const Linear_list<T,P> &l){
	typename Linear_list<T,P>::position p;
	p = l.begin();
	cout << "[";
	while (!l.end(p)){
		if (p != l.begin())
			cout << ", " << l.read(p);
		else
			cout << l.read(p);
		p = l.next(p);
	}
	cout << "]" << endl;
	return os;
}

#endif // _LISTALIN_H
Gamer2015 (810)
ListaCur<T>::typedef ComponenteSpazio<T> SPAZIO
Why did you add the typedef in the middle?

typename ListaCur<T>::ComponenteSpazio<T> *ListaCur<T>::SPAZIO = ListaCur<T>::inizializza();
ComponenteSpazio<T> is no part of ListaCur.
Replace it with SPAZIO, that's what the typedef is for
typename ListaCur<T>::SPAZIO *ListaCur<T>::SPAZIO = ListaCur<T>::inizializza();
Last edited on
Giuggiola (26)
1
2
3
4
5
6
7
8
 
template<class T>
class ListaCur : public Linear_list<T, int>{
public:
         ...
private:
     typedef typename ListaCur<T>::ComponenteSpazio<T> SPAZIO; //10 errors

//[Error] expected unqualified-id before '<' token


Then I want to declare an array SPACE [100] cells or nodes, and its type is' Space Component <T> ', I realized then that typedef I do not need because I do not want to replace the type name ' Space Component ' with ' SPACE ' why ' SPACE ' is the name of the array you want to create. I tried with ComponenteSpazio <T> SPACE [MAXLUNG];
but errors increase.
Giuggiola (26)
and 'SPACE' must be static in order to contain all the lists, including the free list, because the professor told state

static componenteSpazio SPACE [100];

sorry for the discomfort and thanks for your patience and help, but I'm too long on these errors
Pages: 12