[C++] settare variabile in una classe

[gianvituzzi]

Salve,

ho iniziato a studiare le classi in C++ volevo sapere se si può dare subito un valore ad una variabile senza usare un metodo, ad esempio nel seguente codice imposto io il valore di una variabile di tipo string:

#include <stdio.h>
#include <stdlib.h>

class myClass {

public:
	void print();
private:
	void setup();
	typedef char* string;
	string saluto;
};

int main()
{
	myClass* C = new myClass;
	C->print();

	system("pause");
	return 0;
}

inline void myClass::print()
{
	setup();
	printf("%s\n", saluto);
}

inline void myClass::setup()
{
	saluto = "Hello World!";
}

ma se provo a fare:

myClass::saluto = "Hello World!";

mi da errore...

grazie

[shodan]

Se stai studiando il C++, inizia a prendere le buone abitudini
Puoi fare quello che chiedi usando il costruttore della classe.

#include <iostream>
#include <string>

class myClass {

public:
        myClass(const std::string& s) : saluto(s) {}
	void print();
private:
	std::string saluto;
};

int main()
{
	myClass* C = new myClass("Hello World!");
	C->print();
        delete C; // si libera la memoria alla fine.
	std::cin.get();
	return 0;
}

inline void myClass::print()
{
	std::cout<< saluto << std::endl;
}

[gianvituzzi]

se ti riferisci alla typedef e alla printf() hai perfettamente ragione, volevo fare una cosa semplice per adesso, cmq posso implementare il costruttore della classe fuori dalla sua dichiarazione, vero?

class marameo {
public:
	marameo(string);
	void print();
private:
	string saluto;
}

marameo::marameo(const string a) : saluto(a) {}

void marameo::print()
{
	printf("%s\n", saluto);
}

io volevo sapere se posso partire con dei valori costanti già prefissati che fanno parte della classe, ad esempio come potrebbe essere la versione della classe stessa

grazie

[shodan]

Più che alla printf (un pò scomoda in C++, ma perfettamente usabile) mi riferivo al typedef e ai char*. Come nome del typedef avevi scelto proprio quello che va in collisione con la std::string (quando si esplicita il namespace) e questo ti avrebbe causato problemi più avanti.
In C++ è comunque preferibile usare std::string rispetto alle stringhe C e limitare l'uso di queste ultime solo per interfacciarsi con codice C esistente, API del sistema operativo o codice legacy.

Se non hai già un testo di riferimento, ti consiglio Thinking in C++ di Bruce Eckel ( scaricabile liberamente dal suo sito e in altri.)

posso implementare il costruttore della classe fuori dalla sua dichiarazione, vero?

Certamente. Attento però che i prototipi devono essere uguali. (Nel codice ripostato sono diversi).

Per quanto possibile sarebbe meglio fossero:
const Tipo&
quindi nel tuo caso
const std::string&
(Risparmi un costruttore di copia, può ricevere stringhe costanti letterali, etc)

volevo sapere se posso partire con dei valori costanti già prefissati che fanno parte della classe, ad esempio come potrebbe essere la versione della classe stessa

Con il prossimo standard ( e i compilatori che lo supportano, ormai alle porte) sarà possibile scrivere:

private:
	string version="ver. 1.0,0";
}

Con l'attuale no, si può solo inizializzare il valore tramite il costruttore o usando una funzione apposita.

[gianvituzzi]

ok, quindi quindi si potrebbe fare così?

class marameo {
public:
	marameo(const string);
	void print();
private:
	string saluto;
	string versione;
}

marameo::marameo(const string a) : saluto(a), versione("V1.0.0") {}

void marameo::print()
{
	printf("%s\n", saluto);
}

(naturalmente in questo semplice esempio non c'è nessun bisogno di dichiarare/implementare un distruttore, credo)

sto leggendo quel testo insieme ad "Accelerated C++"

grazie

[gianvituzzi]

pardon, /string versione/ è "public:" e mafari anche "static"

[shodan]

Si, (a parte che si perde una & per strada, non marginale.)

(naturalmente in questo semplice esempio non c'è nessun bisogno di dichiarare/implementare un distruttore, credo)

No, in questo caso no. Il distruttore serve quando si devono liberare risorse (variabili allocate nella classe, chiudere un file, liberare un HANDLE etc.)

pardon, /string versione/ è "public:" e mafari anche "static"

Per il costruttore non ha importanza se sono public, protected o private: ci accede comunque.
Se sono static però non puoi inizializzarle così, ma devi farlo fuori dalla classe.
Una variabile static esiste anche se non esiste il suo oggetto.
In questo caso il tutto diventa:

class marameo {
public:
	marameo(const string& ) ;
	void print();
	static string versione;
private:
	string saluto;
};

string marameo ::versione="Ver 1.0.0"; // obbligatorio farlo qui.

marameo::marameo(const string& a) : saluto(a) {}

void marameo::print()
{
	printf("%s\n", saluto);
}

int main () {

    cout << marameo::versione << endl;
    marameo m("ciao");

}

[gianvituzzi]

ma allora se voglio vedere dall'esterno della classe una variabile privata (senza modificarla) l'unico modo è creare un metodo pubblico della classe con lo stesso nome della variabile? (il compito di questo metodo sarà tornare la variabile)

[oregon]

Se è privata ...

[xnavigator]

Originariamente inviato da shodan

class myClass {

public:
        myClass(const std::string& s) : saluto(s) {}
	void print();
private:
	std::string saluto;
};

scusa shodan ma perchè a questo punto non lo scrivi cosi che mi sembra qualcosa di molto più chiaro:

public:
       myClass(std::string s) { saluto = s; }
private:
       std::string saluto;

?