[Programarea Orientată Pe Obiecte - C++] Organizarea Claselor pe mai multe fișiere

[Soulrayne]

Organizarea Claselor

 

Cu cat proiectul primeste mai multe implementari , spre exemplu : mai multe clase , mai multe functii samd. , cu atat acesta devine mai greu de citit . In acest context , a aparut necesitatea de a organiza clasele pe mai multe fisiere . Pentru fiecare clasa , se constituie doua fisiere :

► unu de tip antent sau "header" ce detine declaratiile clasei si a componentelor acestuia . 

► unu de tip sursa ce detine implementarile(functionalitatile) declarate.  

 

NOTA : Aceasta abordare ne confera o LIZIBILITATE mai buna a codului . (O intelegere mai buna a codului prin redimensionarea liniilor de cod la fiecare fisier) . Practic , mai bine preferam 6 fisiere cu cate 50 de linii de cod decat un fisier cu 300 . 

 

Exemplu 

 

Sa presupunem ca avem proiectul nostru de POO (Programarea Orientata Pe Obiecte) , codul fiind incapsulat intr-un singur fisier .  Scopul acestui tutorial , va fi de a impartii acele linii de cod pe mai multe fisiere . (Ne va ajuta in tutorialele urmatoare cand vom complica lucrurile !!) 

 

1. Declaram o clasa ce manipuleaza siruri de caractere (pentru alocarea sirurilor de caractere) : 

 

// StringBZONE.h 

#pragma once

#include "string.h" // Pentru strcpy

/// MANIPULATOR DE SIRURI DE CARACTERE 


class StringBZONE {

private:

	char* string;


public:
	StringBZONE();
	StringBZONE(const char* source); 
	~StringBZONE();

	// Getteri 

    char* const getString();

	// Setteri 

	void setString(const char* source);


	// Alte Functii  

	static inline void allocAndFetchString(char** target, const char* source); // E INDEPENDENT DE INSTANTE 

};

 

Cu implementarea : 

 

// StringBZONE.cpp

#include "StringBZONE.h" // Asociem cu fisierul antent 

// Implementari 

StringBZONE::StringBZONE() // Constructor Default 
{
	const char* defaultBZONEString = "BINE AI VENIT PE COMUNITATEA BZONE!!!";

	allocAndFetchString(&this->string,defaultBZONEString);
   
}

// Constructor cu Parametrii 

StringBZONE::StringBZONE(const char* source)
{
	allocAndFetchString(&this->string,source);
}



// Destructor 

StringBZONE::~StringBZONE()
{
	// Eliberam memoria ocupata de sir 
	delete string;
	string = NULL; 
}

// Getteri && Setteri 

 char* const StringBZONE::getString()
{
	return string;
}

void StringBZONE::setString(const char* source)
{
	delete this->string; // Stergem 
	allocAndFetchString(&string,source); // Realocam pentru alt sir de caractere
}

inline void StringBZONE::allocAndFetchString(char** target, const char* source)
{
	size_t sizeTarget = strlen(source) + 1;
	*target = new char[sizeTarget]; // Alocam Spatiu pentru sir de caractere 
	strcpy_s(*target, sizeTarget, source);
}


// Alte Functii 

 

2. Adaugam Clasa de Utilizatori : 

 

#pragma once
// User.h --> Fisier Antent


#include "StringBZONE.h" 
#include <iostream>


// CLASA CU DECLARATIA MEMBRIILOR 
class User
{
private:  // Sector Privat 
	// Campuri 
	unsigned id;  // NUMAR NATURAL
	char* username; // SIR DE CARACTERE
	char* email; // SIR DE CARACTERE 
	char* password; // SIR DE CARACTERE
	unsigned nrPosts; // NUMAR NATURAL 
	bool isBanned; // E BANAT

	StringBZONE* stringHandling; // Manipuleaza Siruri de Caractere . 

public:  // Sector Public 

	/*
	*   CONSTRUCTORI
	*/

	User(); // Constructor fara parametrii 
	User(unsigned id, const char* username, const char* email, const char* password); // Constructor cu toti parametrii 

	/*
		DESTRUCTOR
	*/
	~User();

	/*
		GETTERI
	*/

	unsigned const getId();
	const char* const getUsername();
	const char* const getEmail();
	const char* const getPassword();
	unsigned const getnrPosts();
	bool const getisBanned();
	/*
	  SETTERI
	*/

	void setNrPosts(const unsigned nrPosts);
	void setIsBanned(const bool isBanned);
	void setUsername(const char* username);
	void setEmail(const char* email);
	void setPassword(const char* password);


	// Alte Functii 

	// Vizualizare Obiect 

	void objectToString();  // Transferam obiectul prin referinta constanta

};

 

Cu implementarea : 

 

#include "User.h"

//** Implementarea Constructorilor **//


User::User() { // Constructor Fara Parametrii 

	// Alocam si Initializam date cu informatii IMPLICITE (DEFAULT )

	// Variabile cu Alocare Statica 
	id = 0;
	nrPosts = 0;
	isBanned = false;

	// Variabile cu Alocare Dinamica 

	stringHandling = new StringBZONE(); // E initializat cu o valoare implicita (default)

	/// FUNCTIILE STATICE SE INVOCA FOLOSIND "::" !!! 
	
	StringBZONE::allocAndFetchString(&this->username, stringHandling->getString());
	StringBZONE::allocAndFetchString(&this->email, stringHandling->getString());
	StringBZONE::allocAndFetchString(&this->password, stringHandling->getString());
}


User::User(unsigned id, const char* username, const char* email, const char* password)
{
	this->id = id;

	stringHandling = new StringBZONE(username); // Apelam constructorul cu parametrii 

	StringBZONE::allocAndFetchString(&this->username, stringHandling->getString());  // Setam Numele de Utilizator 
	stringHandling->setString(email); // Schimbam sirul cu urmatoarea informatie 
	StringBZONE::allocAndFetchString(&this->email , stringHandling->getString()); // Setam Adresa De Mail 
	stringHandling->setString(password);
	StringBZONE::allocAndFetchString(&this->password, stringHandling->getString()); // Setam Parola 

	this->nrPosts = 0; // Implicit 
	this->isBanned = false; // Implicit 
}

User::~User()
{
    // Eliberam Resursele ocupate de siruri 

	delete username;
	username = nullptr;
	delete email;
	email = nullptr;
	delete password;
	password = nullptr;
	delete stringHandling;
	stringHandling = nullptr;
}

unsigned const User::getId()
{
	return this->id;
}

const char* const User::getUsername()
{
	return this->username;
}

const char* const User::getEmail()
{
	return this->email;
}

const char* const User::getPassword()
{
	return this->password;
}

unsigned const User::getnrPosts()
{
	return this->nrPosts;
}

bool const User::getisBanned()
{
	return this->isBanned;
}

void User::setNrPosts(const unsigned nrPosts)
{
	this->nrPosts = nrPosts;
}

void User::setIsBanned(const bool isBanned)
{
	this->isBanned = isBanned;
}

void User::setUsername(const char* username)
{
	stringHandling->setString(username);
	StringBZONE::allocAndFetchString(&this->username, username);
}

void User::setEmail(const char* email)
{
	stringHandling->setString(email);
	StringBZONE::allocAndFetchString(&this->email, email);
}

void User::setPassword(const char* password)
{
	stringHandling->setString(password);
	StringBZONE::allocAndFetchString(&this->password, password);
}

void User::objectToString()
{
		// DOAR AFISAM CAMPURILE OBIECTULUI 

		std::cout << "\n{" << "\nID Utilizator : " << this->id << " ,\n"
			<< "Nume Utilizator : " << this->username << " ,\n"
			<< "Adresa Mail : " << this->email << " ,\n"
			<< "Parola Utilizator : " << this->password << " ,\n"
			<< "Numar Posturi : " << this->nrPosts << ", \n"
			<< "STATUS BANAT : " << (this->isBanned ? "ESTE INTERZIS " : "NU ESTE INTERZIS") << " PE BZONE!!, \n }";
}

 

Si functia centrala care ne instantiaza si afiseaza obiectele : 

 

#include "User.h" // Includem Clasa de Utilizatori 


int main()
{
	User user1,
		user2(1, "Vasile", "vasile@gmail.com", "vasileparola"); // Declaram doua instante (una cu constructoru implicit + constructor cu parametrii )
	// Vizualizam Instantele 

	user1.setUsername("IONEL");

	user1.objectToString(); // Vizualizam Instanta 1 
	user2.objectToString(); // Vizualizam Instanta 2 
	return 0;  
}

 

Rezultatul final fiind : 

 

{
ID Utilizator : 0 ,
Nume Utilizator : IONEL ,
Adresa Mail : BINE AI VENIT PE COMUNITATEA BZONE!!! ,
Parola Utilizator : BINE AI VENIT PE COMUNITATEA BZONE!!! ,
Numar Posturi : 0,
STATUS BANAT : NU ESTE INTERZIS PE BZONE!!,
 }
{
ID Utilizator : 1 ,
Nume Utilizator : Vasile ,
Adresa Mail : vasile@gmail.com ,
Parola Utilizator : vasileparola ,
Numar Posturi : 0,
STATUS BANAT : NU ESTE INTERZIS PE BZONE!!,
 }