articole [Structuri de Date - C] Introducere in Structuri de Date (Articole)

[NEFERPITOU]

** Articole in C ** 

Articolele sunt tipuri de date complexe care stocheaza diferite informatii (de mai multe tipuri de date) dintr-un anumit camp . De exemplu , sa presupunem campul "utilizator" , poate stoca id-ul , numele , parola , data inregistrarii etc. (diferite tipuri de date) 

Articolele(din C) reprezinta  aceeasi ideie de baza precum clasele din C++ doar ca nu se aplica principiile POO (Nu avem concept de incapsulare , polimorfism , mostenire etc.) 

NOTA** : Nu confundam cu articolele din C++ care dobandesc caracteristici POO , mai putin incapsulare (toti membrii sunt publici)  spre deosebire de clasa . (unde avem si privat si protected)

** Exemplu in C ** : 

Definim doua articole (cu o legatura intre ele) :   

// Articole 


typedef struct Roles {   // Definim articolul Roluri  cu doua campuri 
	unsigned id;
	char* nameRole;
}Role; // Sub aceasta eticheta putem construi instante


typedef struct Users {  // Definim articolul Utilizatori cu 6 campuri 

	// Articol sub alt Articol (nested)

	unsigned idUser; // numar natural   
	unsigned nrPosts; // numar natural 
	char* username; // un sir de caractere
	char* email; // un alt sir de caractere 
	char* password; // alt sir de caractere 
    Role* roles; // o colectie de roluri
    unsigned nrRoles;// Retinem in cate grupe se afla

}User;  // Sub aceasta eticheta putem construi  instante 


/// NOTA ** : IN STRUCTURI NU PUTEM AVEA FUNCTII (In C++ e alta poveste)

In a doua faza , definim rolurile pe care utilizator le poate avea : 

/// DEFINIM PRIN MACRO (SIRURI DE CARACTERE CONSTANTE) CATEVA ROLURI 

#define MEMBER "membru"
#define PREMIUM "premium"
#define MODERATOR "moderator"
#define SUPERMODERATOR "superModerator"
#define ADMINISTRATOR "administrator" 

/// DEFINIM NR_ROLURI MAXIM   

#define NR_ROLES 5 
#define MAX_BUFFER_STRING 50 // Numar maxim de biti alocat pentru siruri de caractere (un caracter = un byte)


Role* getRoles()  // Returnam o colectie de NR_ROLES(5 roluri)
{

	Role* roles = (Role*)malloc(sizeof(Role) * NR_ROLES); // Alocam o colectie de 5 roluri (Un Array de 5 ROLURI)

	const char* const newRoles[] = { MEMBER,PREMIUM,MODERATOR,SUPERMODERATOR,ADMINISTRATOR }; // INCARCAM TOATE ROLURILE INTR-O CONSTANTA DE SIRURI DE CARACTERE 
	

	for (int i = 0; i < NR_ROLES; i++)   // PARCURGEM CELE 5 ROLURI 
	{
		roles[i].id = i; // Atribui cu indexul
        // atribuim rolurile din constanta in campul "nume roluri" din cadrul articolului roluri
		size_t bufferName = strlen(newRoles[i]) + 1; // 
		roles[i].nameRole = (char*)malloc(sizeof(bufferName)); // Alocam spatiu pentru campu nostru 
		strcpy_s(roles[i].nameRole,bufferName, newRoles[i]); // Copiem informatia 
	}


	return roles; // Returnam rolurile inregistrate (articol incarcat)
	
}

Nota 1* :  MACRO (alea cu "#define") sunt Constante care pot fi accesate la nivelul fisierului . (in toate subprogramele , mai putin cele de sus de declaratia acestora) ;

Nota 2* : Cand articolul este pointer , pentru accesarea membriilor se foloseste sageata "->" .

 

 A treia parte , consta in incarcarea unui utilizator cu campurile :{ id,nume,email,parola,nrPosturi,roluri detinute} , de la tastatura : 

 

// Functia unde inregistram de la tastatura sirurile de caractere + le livram catre membrii articolului 

void getAndAllocString(char** target)  // Alocam Dinamic fiecare sir de caracter
{ 
	char temp[MAX_BUFFER_STRING]; // Definim o variabila intermediara care ne preia datele primite ca input 

	scanf_s("%s",temp,MAX_BUFFER_STRING); // Luam Sirul de caractere de la tastatura 

	size_t sizeString = sizeof(temp) + 1; // Alocam doar necesarul 

	*target = (char*)malloc(sizeof(char) * sizeString); // Alocam doar memoria necesara 
	strcpy_s(*target, sizeString, temp); // Transferam catre sirul de caractere 
}


void insertUser(User* user , Role* role )  // L am pus pointer sa putem modifica datele , pe rol nu avem nevoie de modificari dar e colectie  
{
	printf("\n Introdu un id : ");
	scanf_s("%d", &user->idUser); // user.idUser  ==> FOLOSIND sageata (pentru ca user e pointer) (->) accesam membrii 
	printf("\n Introdu un nume de Utilizator : ");
	getAndAllocString(&user->username);
	printf("\n Introdu o adresa de Mail : ");
	getAndAllocString(&user->email);
	printf("\n Introdu o parola : ");
	getAndAllocString(&user->password);
	printf("\n Introdu un numar de posturi : ");
	scanf_s("%d", &user->nrPosts);
	printf("\n Dati mi un nivel de autoritate : (Pana la 5) ");
	scanf_s("%d", &user->nrRoles);

	if (user->nrRoles > NR_ROLES)  // Daca nu respecta conditia  
		user->nrRoles = 1;  // Ii atribuim doar un Rol 


	user->roles = (Role*)malloc(sizeof(Role) * user->nrRoles); // Alocam NUMARUL DE ROLURI PE CARE UTILIZATORUL IL DETINE 
	
    // NOTA * : 
   
   /// Aici : nrRoles = 1 ==> "membru" && nrRoles = 2 ==> "membru" & "premium"  &&  nrRoles = 3 ==> "membru" && "premium" && "moderator"  samd. 
   
   // AM FOST PUTIN LENES , AM VRUT DOAR SA ARAT ACCESUL LA COLECTIA DE ROLURI ASOCIAT UTILIZATORULUI RESPECTIV 

	for (int i = 0; i < user->nrRoles; i++)
		user->roles[i] = role[i]; // in functie de numarul de roluri 
} 

Afisam si eliberam utilizatorul  :

#include <stdio.h> // Pentru operatiuni de intrare si iesire (printf , scanfs ) 
#include <stdlib.h> // Pentru malloc , free 
#include <string.h> // Pentru operatiuni cu siruri de caracter

... Restul Codului ... 


void showStructure(User user) // Afisam Structura 
{
	printf_s("Utilizator : \n{\n *ID Utilizator : %d, \n *Nume Utilizator : %s, \n *Adresa Mail : %s, \n *Parola :  %s ,\n *Numar Posturi : %d, \n",
		user.idUser, user.username, user.email, user.password, user.nrPosts);

	printf_s(" *Grupuri din care face parte : { \n ");

	for (int i = 0; i < user.nrRoles; i++)
		printf_s("\t*id Grup : %d | *nume Grup : %s , \n" , user.roles[i].id , user.roles[i].nameRole); // Afisam Id-urile si Grupurile asociate

	printf("} \n\n }");
}

// NU UITAM SA ELIBERAM MEMORIA 

// NOTA* : TOT CE SE ALOCA SE ELIBEREAZA !!!!! 

void freeMemoryRoles(Role* role)
{
	// **  Eliberam Rolurile (In aceeasi maniera cum le am alocat)

	for (int i = 0; i < NR_ROLES; i++)
	   free(role[i].nameRole); // Eliberam sirurile de caracter 

	// **  Eliberam colectia in sine 

	free(role);
	role = NULL; 
}

void freeMemoryUser(User user)
{
	// Eliberam sirurile de caractere 
	free(user.username);
	free(user.email);
	free(user.password);

	free(user.roles); // Eliberam colectia de grupuri 
}

// Executia Subprogramelor 

int main()
{

	Role* newRoles = getRoles(); // Injectam colectia cu o serie de roluri

	User utilizator1;

	// adaugam date intr-un utilizator ; 

	insertUser(&utilizator1,newRoles); // Inseram in Structura 

	showStructure(utilizator1); // Afisam Structura 

	// Eliberam memoria alocata 

	freeMemoryUser(utilizator1);
	freeMemoryRoles(newRoles);
	
	return 0;
}

Si avem ca rezultat : 

Utilizator :
{
 *ID Utilizator : 1,
 *Nume Utilizator : alin,
 *Adresa Mail : alin@gmail.com,
 *Parola :  esacca ,
 *Numar Posturi : 443,
 *Grupuri din care face parte : {
        *id Grup : 0 | *nume Grup : membru ,
        *id Grup : 1 | *nume Grup : premium ,
        *id Grup : 2 | *nume Grup : moderator ,
}
 }

NOTA 1* : Toate datele au fost introduse de la tastatura !!  

NOTA 2* : Putem introduce mai multi utilizatori !! (Voi face la urmatorul tutorial !! )

NOTA 3*: Aveti codul sursa in atasament !!! 

 

entryPoint.c