constructor [Programare Orientate pe Obiecte - C++] Constructor cu Parametrii

[NEFERPITOU]

** Constructor cu Argumente (Parametrii) **

Constructorul sau Constructorii cu parametrii sunt metode care ne permit sa avem instante (obiecte) unice in functie de parametrii luati . De asemenea , pot exista si impreuna cu constructorul implicit . 

Reconstruim clasa de la tutorialul trecut (cu constructorul implicit) + functia de alocare a sirurilor de caractere : 

void atribuireSirCaractere(char** target, const char* source)
{
	size_t bufferString = strlen(source) + 1;

	*target = new char [bufferString];
	strcpy_s(*target, bufferString, source);
}



class Utilizator {

public : 

 // Punem enumul pe public deoarece trebuie sa l accesam din exterior 

  enum class type {   // Tip de Utilizator 
	MEMBER,
	PREMIUM,
	MODERATOR,
	ADMIN
};



private: // Sector Privat (Membrii aflati la acest nivel de acces NU pot fi accesati

	unsigned id; // Numar Natural 
	char* username; // String
	char* email;  // String 
	char* password; // String 
    unsigned nrPosts; // Numar Natural 
    bool isForbidden; // Banat sau NU
    type userType; // Tip Utilizator


public: // Sector Public (Membrii aflati la acest nivel de acces POT FI ACCESATI) 


	Utilizator() { /// Definitie Constructor fara parametrii (argumente)

		//// Definim Stringurile pe care le dorim sa le atribuim campurilor 




		// Initializam campurile statice 
            id = 0; 
            nrPosts = 0;
            isForbidden = false;
            userType = type::MEMBER; // Member by Default 
	

		// Atribuire Nume de Utilizator 
		atribuireSirCaractere(&username, "Vasile"); // Atribuire Nume 
		atribuireSirCaractere(&email, "vasile79@gmail.com"); // Atribuire Email 
		atribuireSirCaractere(&password, "vasileParola");


	}

	// Definim Getteri 

	const unsigned _getIdUser()
	{
		return id;
	}

	const char* const _getUsername()
	{
		return username;
	}

	const char* const _getEmail()
	{
		return email;
	}

	const char* const _getPassword()
	{
		return password;
	}
    const unsigned _getNrPosts()
{
	return nrPosts;
}

const bool _isForbidden()
{
	return isForbidden;
}

	const type _getType()
	{
		return userType;
	}

};

NOTA ** : Am adaugat trei campuri noi ("isForbidden","NrPosts" si "TypeUser") sa devina mai interesant ; 

Acum in clasa respectiva , vom adauga 4 constructori cu paramatrii : 

Utilizator(unsigned _id,type _userType) { // Constructor care preia ca argument  ID-ul si tipul de user ;  
    
	id = _id; // Atribuim id-ul din argumentul preluat  
	userType = _userType; // Atribuim tipul din argumentul preluat  


	// Restu e implicit 

	isForbidden = false;
	nrPosts = 0;
	atribuireSirCaractere(&username, "Vasile"); // Atribuire Nume 
	atribuireSirCaractere(&email, "vasile79@gmail.com"); // Atribuire Email 
	atribuireSirCaractere(&password, "vasileParola");


}

Utilizator(unsigned _id, const char* _username,type _userType)  // Al doilea Constructor cu id si nume preluat 
{
	// Atribuire cu argumente preluate 
	id = _id;
	atribuireSirCaractere(&username, _username);
	userType = _userType;

	// Restu Implicit
    isForbidden = false;
	nrPosts = 0;
	atribuireSirCaractere(&email, "vasile79@gmail.com"); // Atribuire Email 
	atribuireSirCaractere(&password, "vasileParola"); // Atribuire Parola A
}

Utilizator(unsigned _id, const char* _username , const char* _email , const unsigned _nrPosts)  // Al treilea Constructor cu id , nume , email preluat si numar posturi
{
	// Atribuire cu argumente preluate 
	id = _id;
	atribuireSirCaractere(&username, _username);
	atribuireSirCaractere(&email, _email); // Atribuire Email 
	nrPosts = _nrPosts;

	// Atribuire cu argumente default 

	atribuireSirCaractere(&password, "vasileParola"); // Atribuire Parola A
	userType = type::MEMBER;  // Atribuire Tip Utilizator
	isForbidden = false;
  }


/// Constructor care preia toate argumentele 

Utilizator(unsigned _id, const char* _username, const char* _email, 
	      const char* _password,const unsigned _nrPosts,const bool _isForbidden,type _userType) 
{
	// Atribuire cu argumente preluate 
	id = _id;
	nrPosts = _nrPosts;
	isForbidden = _isForbidden;
	userType = _userType;
	atribuireSirCaractere(&username, _username); // Atribuire Nume Utilizator 
	atribuireSirCaractere(&email, _email); // Atribuire Email 
	atribuireSirCaractere(&password, _password); // Atribuire Parola 


}

NOTA **  : PUTEM FACE CATI CONSTRUCTORI CU PARAMETRII DORIM NOI !! (TOTUSI E RECOMANDAT DOAR CE E STRICT NECESAR) 

Pentru a putea afisa un enum ca sir de caractere , avem nevoie de un adaptor in interiorul clasei :  

	static const char* typeUser(type userType)  // O Folosim la nivel static 
	{
		switch (userType)
		{
		case type::ADMIN:
			return "Administrator";
			break;
		case type::MODERATOR:
			return "Moderator";
			break;
		case type::PREMIUM:
			return "Utilizator Premium";
			break;
		default: 
			return "Utilizator Simplu";
			break;
 		}
	}

NOTA ** : L am notat cu  "static" deoarece functia nu depinde de campurile instantei  !! Vom discuta in tutorialele ce urmeaza despre membrii statici , in detaliu !! 

Totodata , construim o alta functie in interiorul clasei care sa ne afiseze datele (Cu scopul de a nu repeta cod aiurea ):

 

	void toString(){    // Interfata de afisare a fiecarui obiect 
		cout << _getIdUser() << " | " <<  _getUsername() << " | "
			<< _getEmail() << " | " << _getPassword() << " | " << _isForbidden()
			<< " | " << _getNrPosts() << " | " << typeUser(_getType()) << endl;
	}

Acum , trecem in functia main si instantiem 5 obiecte (1 cu constructor default  si 4 cu parametrii ) : 

int main()
{

	Utilizator vasileEntitate1; // Instantiat cu Constructorul Default (Implicit)

	// Afisam Campurile :  ID | USERNAME |  EMAIL |  PASSWORD 

	vasileEntitate1.toString();  

	Utilizator vasileEntitate2(1,Utilizator::type::MEMBER); // Instantiere Prim Constructor 

	vasileEntitate2.toString();


	Utilizator ionEntitate(2, "Ion", Utilizator::type::PREMIUM); // Instantiere Al Doilea Constructor 

	ionEntitate.toString();

	Utilizator alinEntitate(3, "Alin", "alin21332@gmail.com" ,50); // Instantiere Al Treilea Constructor

	alinEntitate.toString();

	Utilizator georgeEntitate(4, "George", "george21332@gmail.com", "georgeParola" , 80 , false,Utilizator::type::ADMIN); // Instantiere Al Treilea Constructor

	georgeEntitate.toString();

	return  0;
}

Si primim ca rezultat : 

0 | Vasile | vasile79@gmail.com | vasileParola | 0 | 0 | Utilizator Simplu
1 | Vasile | vasile79@gmail.com | vasileParola | 0 | 0 | Utilizator Simplu
2 | Ion | vasile79@gmail.com | vasileParola | 0 | 0 | Utilizator Premium
3 | Alin | alin21332@gmail.com | vasileParola | 0 | 50 | Utilizator Simplu
4 | George | george21332@gmail.com | georgeParola | 0 | 80 | Administrator