C/C++ - Costruttore con parametri enum

Ciao a tutti,
sto cercando di costruire un oggetto della classe "forcella", nel cui sorgente ho creato un tipo enum:

forcella.h:

#ifndef FORCELLA_H
#define FORCELLA_H

#include "sospensione.h"
#include <iostream>
using namespace std;

enum scelta1{girder,springer,trailingLink,leadingLink};
class forcella : public sospensione{
	friend istream& operator>> (istream&, scelta1&);
public:
	forcella(scelta1=girder,int=0);
	~forcella();
	void setTipo();
protected:
	scelta1 tipo;
};

#endif

ed ecco il main:

#include "componenti/forcella.h"
#include <iostream>
using namespace std;

int main(){
	forcella f(girder,50);
	return 0;
}

Purtroppo il compilatore mi dà: "Symbol 'girder' could not be resolved". Sembra un problema relativo allo scope della enum.. come posso ovviare secondo voi? Ho già provato con qualcosa del tipo forcella::girder, ma non funziona perché la enum non è e non può essere parte della classe forcella :S

Grazie mille in anticipo!

it.cppreference.com/w/cpp/keyword/…

    #ifndef FORCELLA_H
    #define FORCELLA_H
     
    #include "sospensione.h"
    #include <iostream>
    using namespace std;
     
    enum ENU{girder,springer,trailingLink,leadingLink};

    class forcella : public sospensione{
            friend istream& operator>> (istream&, ENU&);
    public:
            forcella(ENU e,int=0);
            ~forcella();
            void setTipo();
    protected:
            ENU tipo;
    };
     
#endif

Hmm continuo ad avere il problema... credevo che non fosse strettamente necessario specificare il nome del parametro nell'interfaccia della classe.
Non è sufficiente scrivere l'implementazione in questo modo?

forcella.cpp

#include "forcella.h"
#include "sospensione.h"
#include <iostream>
using namespace std;

forcella::forcella(scelta1 t,int l) : sospensione(l){
	tipo=t;
}

purtroppo anche se utilizzo l'intero corrispondente al generico elemento della enum mi dà errore.. anche nella pagina che mi hai linkato non riesco a trovare suggerimenti.. come posso fare?

Nell'interfaccia l'identificatore non è necessario.
L'errore è lo stesso di prima?

Posto un esempio (vediamo se può servire):

#include <iostream>
#include"y.h"
using namespace std;

int main(){
    Y prova(C);
    return 0;
}

#ifndef Y_H_INCLUDED
#define Y_H_INCLUDED

#include<iostream>
using namespace std;

enum E{A,B,C};

class Y{
    public:
        Y(E);
    private:
        E tipo;
};

#endif // Y_H_INCLUDED

#include "y.h"

Y::Y(E e){
    cout << e << endl;
    tipo = e;
    cout << tipo << endl;
}

Il ragionamento fila a pennello, infatti il tuo programma funziona. Il fatto è che non riesco a capire cosa ho fatto di diverso da te e dove si annida il mio problema.
Cercherò di contestualizzare un attimo il tutto: devo costruire una classe "motocicletta" con tutte le sue componenti. Le singole componenti che ho deciso di considerare (forcella,forcellone,motore,ruota,serbatoio) sono delle classi da cui motocicletta eredita gli attributi, in particolare le classi forcella e forcellone derivano dalla classe sospensione.
Dato che esistono dei tipi specifici di forcella e di forcellone ho deciso di rappresentarli con delle enum, definite rispettivamente nei files forcella.h e forcellone.h (ma non all'interno delle classi, quindi proprio come l'esempio che mi hai fatto vedere).

La situazione è quindi la seguente:
forcella.h

#ifndef FORCELLA_H
#define FORCELLA_H

#include "sospensione.h"
#include <iostream>
using namespace std;

enum scelta1{girder,springer,trailingLink,leadingLink};

class forcella : public sospensione{
	friend istream& operator>> (istream&, scelta1&);
public:
	forcella(scelta1 t,int=0);
	~forcella();
	void setTipo();
protected:
	scelta1 tipo;
};

#endif

forcella.cpp

#include "forcella.h"
#include "sospensione.h"
#include <iostream>
using namespace std;

forcella::forcella(scelta1 t,int l) : sospensione(l){
	tipo=t;
}

istream& operator>> ( istream& in, scelta1& x ){
	int val;
	if ( in>> val ) {
		switch ( val ) {
			case 0: case 1: case 2: case 3:
				x = scelta1(val); break;
			default:
				cout<<"Invalid value for type X"<<endl;
			break;
		}
	}
	return in;
}

void forcella::setTipo(){
	scelta1 t;
	cout<<"Inserisci il numero corrispondente al tipo del forcellone... "<<endl;
	cout<<"0)girder; 1)springer; 2)trailingLink; 3)leadingLink"<<endl;
	cin>>t;
	tipo=t;
}

forcella::~forcella(){
	cout<<"Forcella distrutta!"<<endl;
}

motocicletta.h

#ifndef MOTOCICLETTA_H
#define MOTOCICLETTA_H

#include "componenti/motore.h"
#include "componenti/serbatoio.h"
#include "componenti/forcella.h"
#include "componenti/forcellone.h"
#include "componenti/ruota.h"

class motocicletta :
	public motore,public serbatoio,public forcella,public forcellone,
	public ruota{

	friend ostream& operator<<(ostream&,motocicletta&);
public:
	motocicletta(char*,char*,scelta1,int,scelta2,int,int,int,bool,int,int);
	~motocicletta();
private:
	char * marca;
	char * modello;

};

#endif

motocicletta.cpp

#include "motocicletta.h"
#include <string.h>
#include <iostream>
using namespace std;

motocicletta::motocicletta(char* mar,char* mod,scelta1 tip1,int l1,scelta2 tip2,int l2,int c,int diam,bool gonf,int liv, int max)
: forcella(tip1,l1),forcellone(tip2,l2),motore(c),ruota(diam,gonf),serbatoio(liv,max){
	marca=new char [strlen(mar)+1];
	strcpy(marca,mar);
	modello=new char [strlen(mod)+1];
	strcpy(modello,mod);
	cout<<"Motocicletta creata!!"<<endl;

}

motocicletta::~motocicletta(){
	cout << "Motocicletta distrutta!"<<endl;
}

ostream& operator<<(ostream& fuori,motocicletta& m){
	fuori<<"Marca: "<<m.marca<<" Modello: "<<m.modello<<" Tipo forcella: "<<m.forcella::tipo<<endl;
	fuori<<" Lunghezza forcella: "<<m.forcella::lunghezza<<" Tipo forcellone: "<<m.forcellone::tipo<<endl;
	fuori<<" Lunghezza forcellone: "<<m.forcellone::lunghezza<<" Cilindrata: "<<m.cilindrata<<endl;
	fuori<<" Diametro ruota: "<<m.diametro<<" Massimo carburante: "<<m.massimo<<endl;
	fuori<<" Attuale livello carburante: "<<m.livello<<endl;
	fuori<<" Le sue ruote sono ";
	if(m.gonfia)
		fuori<<"gonfie";
	else
		fuori<<"sgonfie";

	return fuori;
}

main.cpp

#include "motocicletta.h"
#include "componenti/forcella.h"
#include "componenti/forcellone.h"
#include <iostream>
using namespace std;

int main(){
	motocicletta moto1("Triumph","Scheggia",girder,50,stampato,60,2000,50,true,100,500);
	cout<<"La mia nuova moto e': "<<endl<<moto1;
	forcella f(girder,50);
	return 0;
}

Quando faccio il build, il tipo forcella ed il tipo motocicletta vengono riconosciuti, ma persiste l'errore "Symbol 'girder' could not be resolved".
La domanda è: per come è scritto il programma, non dovrebbe automaticamente riconoscere il tipo enum "scelta2" e tutte le sue istanze?
Grazie mille per l'aiuto

Prova a definire l'enumerazione in un header a parte e successivamente includilo dove ti serve.
Dato che riconosce le varie istanze non dovrebbe essere un problema di linker.
Si, i valori delle enumerazioni dovrebbero essere riconosciuti in automatico. (Facendo attenzione ai conflitti)

Purtroppo ancora niente da fare, grazie mille per l'aiuto
a volte penso che sia Eclipse a dare i numeri, perché i conti non tornano.. mah.

Se riuscirò a trovare una soluzione te lo farò sapere