[Structuri de Date - C] Fisiere & Articole (Partea 1)

[NOT a MERCEDES]

** Fisiere **

Fisierele reprezinta o alta modalitate de a inregistra  , de a prelucra si de a vizualiza date , pe langa cea de la tastatura . Limbajul C ne ofera capacitate de prelucrare a fiesierelor tip : 

• fisiere text , unde putem observa caractere de tip ASCII (litere,numere,caractere speciale precum "\t" sau "\n"  pentru spatiere samd.) . Poate fi inteles de catre utilizator . 
• fisiere binare , unde observam o succesiune de biti  , ce pot reprezenta informatii precum structuri  de date ,  imagini , fisiere compresate , sunete  samd. Informatia este structurata astfel incat sa fie interpretabila de catre sistem . In schimb , utilizatorul nu l poate descifra . 

NOTA 1 ** :  Putem efectua atat operatiuni intrare(citire) cat si iesire(scriere), pentru fiecare tip de fisier . 

NOTA 2 ** : VOM EFECTUA ANUMITE SCHIMBARI PE PLAN DE ORGANIZARE A FUNCTIONALITATILOR . ASTFEL CA , VOM ORGANIZA TOATE FUNCTIILE IN FISIERE SEPARATE . PENTRU FIECARE CONTEXT , VOI IMPARTII DATELE IN DOUA : FISIERE HEADER SI SURSA ASOCIATA ACESTEIA . PRIMA CONTINE DECLARATIILE VARIABILELOR,CONSTANTELOR,STRUCTURILOR SAU A FUNCTIILOR IAR CEALALTA VA PREZENTA IMPLEMENTARILE ASOCIATE ACESTORA !! MAI BINE MAI MULTE FISIERE CU 50 100 LINII DE COD DECAT UNU SINGURU CU 10000 . 

PROBLEMA DIN ACEST TUTORIAL : Vom introduce cateva roluri dintr-un fisier text , le vom afisa si le vom sterge din memorie (la final) . 

1. Primul Context --> Prelucrearea Sirurilor de Caractere 

stringHandling.h --> numele fisierului (DECLARATII)

// CONTINUT 

#pragma once

#include "string.h" // Pentru strcpy_s , strlen 
#include "stdlib.h" // Pentru malloc 

// FUNCTII & CONSTANTE PENTRU MANIPULAREA SIRURILOR DE CARACTERE

// MACROS


#define STRING_LENGHT(string) (strlen(string)+1) // NE DETERMINA LUNGIMEA SIRULUI DE CARACTERE + 1 (NULL CARACTER)  


// Functii 

void allocAndFetchString(char** target, char* source);

// PE PARCURS , VOM ADAUGA FUNCTIONALITATI NOI 

Si fisierul cu implementarea : 

#include "../StructuriDate/stringHandling.h" // Legam cu fisierul header asociat acestuia

void allocAndFetchString(char** target, char* source)
{
	size_t sizeTarget = STRING_LENGHT(source);
	*target = (char*)malloc(sizeTarget); // Alocam cu dimensiunea ajustata 
	strcpy_s(*target,sizeTarget, source); // Copiem informatia spre noul string 
}

2. Al doilea Context --> Prelucrarea Fisierelor :

#pragma once

#include "stdio.h" // pentru operatiuni cu fisiere 

#define  READMODE_TXT   "r"  // CONSTANTA CITIRE FISIERE TEXT EXISTENTE IN DIRECTOR 

/*
	* Primul parametru "file" va fi asociat cu fisierul pe care l deschidem
	* Al doilea parametru , e numele fisierului
	* Al treila parametru , e modalitatea de citire&scriere (SUNT 12 MODALITATI DE CITIRE/SCRIERE)
	* "w" --> citim fisiere text (EXISTA DEJA --> IL VA SUPRASCRIE && DACA NU --> IL VA CONSTRUI AUTOMAT) ;
	* "r" --> citim fisiere text (DACA NU EXISTA --> VA RETURNA EROARE) ;
	* "a" --> adaugare informatie fisier text (EXISTA DEJA --> IL VA SUPRASCRIE && DACA NU --> IL VA CONSTRUI AUTOMAT) ;
	* "wb" --> scriem in fisiere binare (idem "w") ;
	* "rb" --> citim in fisiere binare (idem "r") ;
	* "ab" --> citim in fisiere binare (idem "a") ;
	* "w+" --> citim & scriem in fisiere text (idem "w") ;
	* "r+" --> citim & scriem in fisiere text (idem "r") ;
	* "a+" --> citim & scriem & modificam in fisiere text (idem "a") ;
	* "wb+" --> citim & scriem in fisiere binare (idem "w");
	* "rb+" --> citim & scriem in fisiere binare (idem "r") ;
	* "ab+" --> citit & scriem & modificam in fisiere binare (idem "a");
	*
	 */


// Functie care returneaza un fisier la care se asociaza numele acestuia 
// cat si modalitatea de citire/scriere  
FILE* openFile(const char* nameFile, const char* readMode); 

Si implementarea acestuia : 

fileHandling.c --> numele fisierului
#include "../StructuriDate/fileHandling.h" // Asociem cu fisierul header a acestuia 

FILE* openFile(const char* nameFile, const char* readMode) // Aplicam modificari catre pointer
{

	FILE* file = NULL;

	errno_t errFileOpen = fopen_s(&file, nameFile, readMode); // Deschidem fisierul in functie de parametrii ceruti
   

	if (errFileOpen) // DACA A INTAMPINAT O EROARE (DE EXEMPLU : NU GASESTE FISIERUL TEXT IN DIRECTOR UNDE SE AFLA SI SURSELE !!)
		printf("Error : %d \n", errFileOpen);

	else // DACA TOTUL E IN REGULA 
		printf("**FISIERUL %s S-A DESCHIS CU SUCCES !**\n", nameFile);

	return file;
}

3. Al treilea Context --> Operatiuni de inserare , parcurgere , modificare si stergere pentru roluri : 

 

#pragma once

#include <stdlib.h> // Pentru malloc realloc 
#include <stdio.h>  // Pentru operatiuni de intrare/iesire 

#include "../StructuriDate/stringHandling.h" // Folosim functiile si Constantele din acest header (allocAndFetchString)


// Definim constante necesare 

#define MAX_BUFFER_STRING_ROLES         30 // MAXIM BITI ALOCATI PENTRU ROLURI 
#define DELIMITATER                     "|"  // Delimitator pentru separarea datelor (id de nume)
#define FILENAME_INPUT_ROLES            "dateIntrareRoluriLeagueCS.txt" // ACEST NUME TREBUIE SA AIBA FISIER SA POATA FI CITIT 

// Definim Structura pentru fiecare rol 

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


// Definim functii pentru incarcarea , accesarea , modificarea si stergerea acestora . 

Role* fetchRoles(FILE* rolesInput); // Incarcam Rolurile in memorie  
void showRoles(Role* roles); // Afisam Rolurile 
void freeRoles(Role* roles); // Stergem rolurile din memorie

Si implementarea acestuia : 

roles.c --> numele fisierului
#include "../StructuriDate/roles.h" // Legam cu headerul asociat acestuia 

Role* fetchRoles(FILE* rolesInput) // Preluam din fisier 
{
	if (rolesInput == NULL) // FISIER NEASOCIAT SAU INVALID 
		return NULL;  // RETURNAM NULL 

	// Daca nu 

	Role* roles = (Role*)malloc(sizeof(Role)); // Alocam un rol pe moment 

	char bufferLine[MAX_BUFFER_STRING_ROLES]; // Va Stoca liniile 

	unsigned i = 1;

	while (fgets(bufferLine,MAX_BUFFER_STRING_ROLES, rolesInput)) // Citim fiecare linie pana nu mai avem de citi
	{

		char* pieceOfLine, * nextPieceOfLine;

		pieceOfLine = strtok_s(bufferLine, DELIMITATER, &nextPieceOfLine); // Preluam ID-ul (PRIMA PARTE A LINII)

		roles[i - 1].id = atoi(pieceOfLine); // CONVERTIM LINIA IN intreg prin "atoi"

		pieceOfLine = strtok_s(NULL, DELIMITATER, &nextPieceOfLine); // Preluam NUMELE (PARTEA A DOUA A LINII)

		allocAndFetchString(&roles[i-1].nameRole,pieceOfLine);


		if (!feof(rolesInput)) // Verificam daca suntem la finalul fisierului 
		{
			roles[i - 1].isLastRole = 0; // Inca nu avem ultimul rol
			roles = realloc(roles, sizeof(Role) * (++i)); // Mai alocam spatiu pentru un rol
		}

		else
			//Daca da 
			roles[i - 1].isLastRole = 1; // Avem ultimul rol 
	}
	return roles;
}

void showRoles(Role* roles)
{
	unsigned i = 0;

	printf_s(" Colectia de Roluri : { \n");

	do {  // Parcurgem colectia de roluri 
		printf_s("ID ROL : %d \t NUME ROL : %s\n", roles[i].id, roles[i].nameRole);
		i++;
	} while (!roles[i-1].isLastRole);

	printf_s(" } \n\n");
}


void freeRoles(Role** roles)
{
	unsigned i = 0;
	do   // Parcurgem fiecare Rol 
	{
		free((*roles)[i].nameRole); // Si eliberam memoria alocata de numele rolului 
		i++;
	} while (!(*roles)[i - 1].isLastRole);

	free(*roles);  // Eliberam colectia 
	*roles = NULL;
}

Al patrulea context --> Este reprezentat de "entry pointul" (punctul de start) a proiectului  (Aici doar gestionam functionalitatile) : 

/* Legam toate entry point toate headerele dependente */
#include "../StructuriDate/roles.h" 
#include "../StructuriDate/fileHandling.h"

// stringHandling.h nu este dependent de entry point 


int main()
{
	FILE* file;
	file = openFile(FILENAME_INPUT_ROLES,READMODE_TXT);

	// dateIntrareLeagueCS.txt && dateIntrareRoluriLeagueCS.txt TREBUIE SA EXISTE IN DIRECTOR (ALTFEL VA ESUA)

	Role* roles = fetchRoles(file); // Am primit lista cu rolurile 
 
	showRoles(roles); // Afisam Rolurile 


	// ELIBERAM RESURSELE 

	freeRoles(&roles); // Eliberam resursele ocupate de entitate 
	fclose(file); // Eliberam resursele ocupate de fisier 


	return 0;
}

Primim ca rezultat : 

 Colectia de Roluri : {
ID ROL : 0       NUME ROL :  Membru

ID ROL : 1       NUME ROL :  Utilizator Premium

ID ROL : 2       NUME ROL :  Moderator

ID ROL : 3       NUME ROL :  Super Moderator

ID ROL : 4       NUME ROL :  Administrator
 }

 

Pe scurt , am declarat si am asociat un fisier pentru a obtine date din el . Pe urma , am incarcat datele intr-o colectie de Roluri(roles , unde i poate fi in functie de cate linii s - au introdus in fisier , cu conditia de A RESPECTA MODELUL !! (id | nume_rol)) . Dupa , am afisat in consola si am eliberat resursele ocupate de colectie cat si de fisier . 

NOTA ** : Voi face cat de curand , un repository (GitHub) pentru a intelege mai bine organizarea fisierelor !! 

 

 

dateIntrareRoluriLeagueCS.txt