Curs 13

Programarea calculatoarelor
Limbajul C
Programe complexe
Directive preprocesare
Convenii programare
CURS 13
Programe complexe. Compilri
separate. Fi#iere proiect.
Funciile unei aplicaii complexe se pot afla n mai
multe fi!iere surs$, compilate separat !i legate
mpreun$ ntr-un singur program executabil.
Modific$ri ale programului se vor face prin editarea !i
recompilarea unui singur fi!ier surs$ (sau a ctorva
fi!iere) !i nu a ntregului program (se evit$
recompilarea unor funcii care nu au suferit
modific$ri).
Programe complexe. Compilri
separate. Fi#iere proiect.
Este posibil$ dezvoltarea !i testarea n paralel a
unor funcii din aplicaie de c$tre persoane diferite.
Specificarea fi!ierelor obiect (OBJ) care vor fi legate
ntr-un singur executabil se face printr-un fi!ier
proiect atunci cnd se lucreaz$ cu un mediu integrat
(IDE) cum este Dev-C++.
In forma sa cea mai simpl$ un fi!ier proiect este o
list$ de nume de fi!iere surs$ (C sau CPP) !i/sau
fi!iere obiect (OBJ) !i/sau biblioteci (LIB) care
contribuie la producerea unui fi!ier executabil.
Etape elaborare
nelegerea specificaiilor problemei de rezolvat !i
analiza unor produse software asem$n$toare
stabilirea funciilor de bibliotec$ care pot fi folosite !i
verificarea modului de utilizare a lor (pe exemple
simple)
determinarea structurii mari a programului: care
sunt principalele funcii din componena programului
!i care sunt eventualele variabile externe
Exemplu
program care s$ realizeze efectul comenzii DIR din
MS-DOS (dir !i ls din Linux): s$ afi!eze numele !i
atributele fi!ierelor dintr-un director dat explicit sau
implicit din directorul curent.
va conine cel puin trei module principale :
preluare date iniiale (input),
obinere informaii despre fi!ierele cerute (getfiles)
prezentarea acestor informaii (output), plus un program
principal.
module realizate ca fi!iere surs$ separate
Dezvoltarea n etape
Definirea progresiv$ a funciilor din
componena aplicaiei, fie de sus n jos (top-
down), fie de jos n sus (bottom-up), fie
combinat.
Abordarea bottom-up
definirea unor funcii mici, care vor fi apoi apelate
n alte funcii, s.a.m.d. pn$ se ajunge la
programul principal.
Dezvoltarea n etape
Abordarea top-down
stabile!te funciile importante !i programul
principal care apeleaz$ aceste funcii.
se define!te fiecare funcie, folosind eventual alte
funcii nc$ nedefinite, dar care vor fi scrise
ulterior.
Exemplu:
void main(int argc, char * argv[]) {
char *files[MAXF]; // vector cu nume de fi!iere
int nf; // numar de fi!iere
getargs (argc,argv); // preluare date
nf=listFiles(files); // creare vector de fi!iere
printFiles(files,nf); // afisare cu atribute
}
Compilri separate
Compilarea separat$ a unor p$ri din
programele mari:
Enumerarea modulelor obiect !i bibliotecilor
statice componente.
Descrierea dependenelor dntre diverse fi!iere
(surse, obiect, executabile) astfel ca la
modificarea unui fi!ier s$ se realizeze automat
comenzile necesare pentru actualizarea tuturor
fi!ierelor dependente de cel modificat.
Dezvoltare programe complexe.
Compilri separate
Dezvoltarea de programe C n mod linie de
comand$:
Enumerarea fi!ierelor obiect !i bibliotecilor n
comanda de linkeditare.
Exemplu:
BCC M.CPP F1.CPP F2.CPP
Utilizarea unui program de tip make !i a unor
fi!iere ce descriu dependene ntre fi!iere !i
comenzi asociate (makefile).
Cnd se folose!te un mediu integrat pentru
dezvoltare (IDE) soluia o constituie fi!ierele proiect.
Fi#iere antet (header)
Funciile unei aplicaii pot folosi n comun:
tipuri de date definite de utilizatori
constante simbolice
variabile externe
Elementele comune se definesc de obicei n fi!iere
antet (de tip H), care se includ n compilarea
fi!ierelor surs$ cu funcii (de tip C sau CPP).
Tot n aceste fi!iere se declar$ funciile folosite n
mai multe fi!iere din componena aplicaiei.
Fi#iere antet (header) con&inuare
Exemplu:
#define MAXC 256 // dimensiunea unor siruri
#define MAXF 1000 // numar de fi!iere estimat
struct file {
char fname[13]; // nume fi!ier (8+3+.+0)
long fsize; // dimensiune fi!ier
char ftime[26] ; // data ultimei modificari
short isdir; // daca fi!ier director
};
int f(int, float);
Fi!ierul antet dirlist.h poate include !i fi!iere antet
standard comune (stdio.h, stdlib.h); este ns$
posibil ca includerile de fi!iere antet standard s$ fac$
parte din fiecare fi!ier surs$ al aplicaiei.
Directive de preprocesare
Suprimarea unei definiii
#undef identificator
Compil$ri condiionate de expresii
#if expresie_constanta
else
#endif
Compil$ri condiionate de definire constante simbolice
#ifdef NUME
#endif
#ifndef NUME
#endif
Directivele din grupul if au mai multe forme, iar un bloc if ...
endif poate conine !i o directiv$ elseif
Programe complexe. Compilri separate.
Fi#iere proiect.
Pentru a evita includerea multipl$ a unui fi!ier antet (standard
sau nestandard) se recomand$ ca fiecare fi!ier antet s$
nceap$ cu o secven$ de felul urm$tor:
#ifndef HDR
#define HDR
// coninut fi!ier HDR.H ...
#endif
O soluie alternativ$ este ca n fi!ierul ce face includerea s$
avem o secven$ de forma urm$toare:
#ifndef STDIO_H
#include <stdio.h>
#define STDIO_H
#endif
o variabila sau o funcie declarata extern este vizibil$ !i n alt
fi!ier decat cel n care este definit$
permite referirea unei variabile globale definit$ n afara unit$ii
de program.
/* fi!ierul main.c */
#include"header.h"
int a = 1, b = 2, c = 3; /* variabile globale */
int f(void); /* prototip */
int main(void){
printf("a = %d, b = %d, c = %d, f = %d\n", a, b, c, f());
system("pause");
return 0;
}
Clasa Extern de alocare a memoriei
/* fi!ierul funcia.c */
int f(void){
extern int a; /* cauta a n afara fi!ierului */
int b, c; /* b, c locale */
b = c = 22;
return (a + b + c);
}
/* fi!ierul antet.h */
#ifndef HDR
#define HDR
#include<stdio.h>
#include<stdlib.h>
#endif
Clasa Extern de alocare a memoriei
Variabile externe
Se definesc ntr-unul din fi!ierele surs$ ale aplicaiei
char path[MAXC], mask[MAXC], opt[MAXC]; // var comune
Domeniul implicit al unei variabile globale este
fi!ierul n care variabila este definit$ (mai precis,
funciile care urmeaz$ definiiei).
Declarare variabil$ cu atributul extern, n toate
fi!ierele n care se fac referiri la ea.
Exemplu :
extern char path[MAXC], mask[MAXC], opt[MAXC];
Variabilele externe continuare
Pentru a evita declaraiile extern n toate fi!ierele
surs$, mai putin fi!ierul ce conine definiiile
variabilelor externe:
Se define!te n fi!ierul surs$ cu definiiile
variabilelor externe un nume simbolic oarecare:
#define MAIN
In fi!ierul dirlist.h se plaseaz$ toate declaraiile
de variabile externe, ncadrate de directivele if !i
endif:
#ifndef MAIN
extern char path[MAXC], mask[MAXC], opt[MAXC];
#endif
Best practices: Foarte important!
Dezvoltarea progresiv$ a programelor, cu teste ct
mai complete n fiecare etap$!
P$strarea versiunile corecte anterioare, chiar
incomplete, pentru a putea reveni la ele dac$ prin
extindere se introduc erori sau se dovedeste c$
soluia de extindere nu a fost cea mai bun$!
Comentarea rolului unor variabile sau instruciuni se
va face chiar la scrierea lor n program !i nu ulterior!
Exemplu
1. O mulime de numere poate fi reprezentat$ printr-o
structur$ care grupeaz$ un vector de ntregi !i
dimensiunea sa. S$ se scrie un proiect care conine
urm$toarele:
Definiia tipului mulime !i antetele funciilor definite
- ntr-un fi!ier set.h:
typedef struct { ... } set;
etc.
Funcii pentru operaii cu mulimi (cu argument de
tip "set" sau "set*") ntr-un fi!ier set.c:
- c$utare ntreg ntr-o mulime (cu rezultat 0 sau 1)
- creare mulime vid$
Exemplu
- ad$ugare ntreg la o mulime, dac$ nu exista deja
- eliminare ntreg dat dintr-o mulime
- intersecia a dou$ mulimi
- citirea unei mulimi
- afi!area unei mulimi
- test mulime vid$
Un program principal care cite!te dou$ mulimi !i
afi!eaz$ mulimea intersecie a celor dou$ ntr-un
fi!ier "test.c".
Se vor utiliza directive de compilare condiionat$
pentru evitarea includerii multiple a fi!ierului header
Rezolvare
//Set.h
#ifndef SET_H
#define SET_H
#include<stdio.h>
#include<stdlib.h>
typedef struct {
int v[100];
int n;
}Set;
void init(Set *);
void add(Set *, int);
void read(Set *);
void print(Set);
int empty (Set);
int search(Set , int);
void del(Set *, int);
Set intersect(Set , Set);
#endif
//Set.c
#include "set.h"
int search (Set a, int x) {
int i;
for (i=0; i<a.n; i++)
if ( a.v[i] == x ) return i;
return -1;
}
void init (Set *a) {
a->n = 0;
}
void add (Set *a, int x) {
a->v[a->n++] = x;
}
int empty (Set a){
return a.n==0;
}
Rezolvare
void read (Set *a){
int i;
printf ("Numar elemente mul&ime:\n");
scanf ("%d", &a->n);
printf("Elemente mul&ime:\n");
for (i=0; i<a->n; i++)
scanf ("%d", &a->v[i]);
}
void print (Set a){
int i;
printf ("Numar elemente mul&ime: %d\n", a.n);
if(!empty(a)){
printf ("Elemente mul&ime:\n");
for (i=0; i<a.n; i++)
printf ("%5d", a.v[i]);
printf ("\n");
}
}
Rezolvare
void del (Set *a, int x){
int i, j;
if ( (i=search(*a,x)) != -1){
for (j=i; j<a->n-1; j++) a->v[j] = a->v[j+1];
a->n--;
}
}
Set intersect(Set a, Set b){
int i;
Set c;
init(&c);
for (i=0; i<a.n; i++)
if ( search(b,a.v[i])!= -1) add(&c, a.v[i]);
print(c);
return c;
}
Rezolvare
//Test.c
#include"set.h"
int main(){
Set a, b;
read(&a);
read(&b);
print(intersect(a,b));
system("pause");
return 0;
}
Rezolvare
Conven&ii de programare
Beneficii:
Uniformizeaz$ modul de scriere a codului
Faciliteaz$ citirea !i nelegerea unui program
Faciliteaz$ ntreinerea aplicaiilor
Faciliteaz$ comunicarea ntre membrii unei echipe
ceea ce duce la un randament sporit al lucrului n
echip$
Obs:
Permite manifestarea creativit$ii programatorului
Poate fi imbun$t$it !i adoptat ca standard
Conven&ii de programare: Variabile
Toate variabilele se definesc nainte de partea de
cod propriu-zis (instruciuni)
Variabilele locale se definesc cte una pe linie;
excepie fac indec!ii, variabilele temporare !i
variabilele iniializate cu aceea!i valoare
int Zone;
int i, j, counter;
int Mode = k = 0;
Variabilele locale ar trebui iniializate nainte de
utilizare
Se va evita utilizarea variabileleor globale pe ct
posibil
Conven&ii de programare: Dimensiune
vectori
Nu se transmite dimensiunea maxim$ a unui vector
cnd acesta este parametru al unei funcii; aceasta
se transmite separat ntr-o variabil$
Nerecomandat
char *substring(char string[80], int start_pos, int length)
{
}
Recomandat
char *substring(char string[], int start_pos, int length)
{
}
Conven&ii de programare: Identificatori
Identificatorii trebuie s$ ndeplineasc$ standardul
ANSI C (lungimea<31, caractere permise: litere,
cifre, _)
Simbolul _ nu va fi folosit ca prim caracter al unui
identificator
Nu se vor folosi nume utilizate de sistem dect dac$
se dore!te nlocuirea acestora (constante, fi!iere,
funcii)
Toate fi!ierele header vor avea extensia .h
Toate constantele simbolice definite cu #define vor fi
scrise cu litere mari
Numele unui fi!ier nu trebuie s$ dep!easc$ 14
caractere n lungime (cu extensie)
Variabilele locale, definiiile de tip (typedef), numele de fi!iere
cat !i membrii unei structuri vor fi scri!i cu litere mici
Numele variabilelor !i funciilor trebuie s$ fie semnificative !i n
concordan$ cu ceea ce reprezint$
Contor, index: g, h, i, j, k, l
Pointeri: ptr_var, var_ptr, var_p, p_var, p
Variabile temporare: tmp_var, var_tmp, t_va
Valori returnate: status, return_value
Funcii: readValues, reset_status, print_array
Fi!iere: initialData.txt, entry.txt, setFuncions.c, set.h
Variabilele globale trebuie s$ se diferenieze de cele locale (fie
primul caracter liter$ mare, fie un sufix de genul global):
Vec_initial, vec_global, set_glb
Conven&ii de programare: Func&ii
Se vor folosi pe ct posibil funcii standard n loc de
funcii specifice sistemului de operare
System Dependent
open(), close(), read(), write(), lseek(), etc...
ANSI Funcions
fopen(), fclose(), fread(), fwrite(), fseek(), etc...
Toate funciile vor avea tip definit explicit
Funciile care ntorc pointeri vor returna NULL n
cazul nendeplinirii unei condiii
Num$rul parametrilor unei funcii ar trebui limitat la
cinci sau mai puin
Toate funciile definite trebuie nsoite de antete ce
vor conine lista tipurilor parametrilor
Conven&ii de programare: Constante
Toate constantele folosite ntr-un fi!ier vor fi definite
nainte de prima funcie din fi!ier
Dac$ se definesc constantele TRUE !i FALSE,
acestea trebuie s$ aib$ valoare 1, respectiv 0:
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
Definirea de constante simbolice (#define) va fi
preferat$ utiliz$rii directe a valorilor:
#define NMAX 100
int a[NMAX];
Conven&ii de programare: Coding
practices
Se recomand$ utilizarea standardului ANSI C pentru
portabilitate
Programele nu trebuie s$ depind$ de caracteristicile
compilatorului (ordinea de evaluare a expresiilor
k = ++i + i; /*gresit */
y = f(x) + z_glb; /*gresit daca f() schimba valoarea lui
z_glb*/
k = ++i + j++; /* OK */
a[i++] = j++; /* OK */
Orice definire (structura, enumerare, tip, etc) utilizat$ n
mai multe fi!iere va fi inclus$ ntr-un fi!ier antet (.h)
Toate conversiile de tip vor fi f$cute explicit
Variabilele structura se vor transmite prin adresa
Pentru constantele utilizate pentru activarea /
dezactivarea unor instruciuni se va verifica definirea
acestora utiliznd compil$rile condiionate
Nerecomandat
#define DEBUG 4 /* used for level of debugging desired */
for (i = 0; i < 5 && DEBUG; i++)
{
printf(i = %d\n, i);
}
Recomandat
#define DEBUG
#ifdef DEBUG
for (i = 0; i < 5; i++)
{
}
#endif
Pentru un simbol testat cu #ifdef, #ifndef sau #if defined nu se
va defini o valoare
Nerecomandat
#define DEBUG 0
#ifdef DEBUG
for (i = 0; i < 5; i++)
{
}
#endif
Recomandat
#define DEBUG
#ifdef DEBUG
for (i = 0; i < 5; i++)
{
}
#endif
Elementele unui vector vor fi accesate utiliznd
[] !i nu operatorul de derefereniere *.
Nerecomandat
int array[11];
*(array + 10) = 0;
Recomandat
int array[11];
array[10] = 0;
Transmiterea parametrilor prin pointeri va fi evitat$
ori de cate ori este posibil
x = f(a, b, c) !i x = f(a, b, c, x)
sunt mai u!or de neles dect
f(a, b, c, &x)
Toate instruciunile switch vor avea clauza
default care ntotdeauna va fi ultima
switch (int_variable)
{
case:..
break;
case:..
break;
default:..
break;
}
Operatorul , va fi utilizat doar n instruciunea for !i
la declararea variabilelor
Modificarea unui cod existent se va face conform
standardului existent deja n acel cod
Modulele unui program nu trebuie s$ dep$!easc$ un
anumit grad de complexitate !i un anumit num$r de
linii (maxim o jum$tate de pagina)
Se va utiliza evaluarea condiiei afirmative mai
degrab$ dect a celei negative (!)
Condiiile logice vor fi scrise explicit
Nerecomandat
if (is_available)
if (sys_cfg__is_radio_retry_allowed())
if (intermediate_result)
Recomandat
if (is_available == FALSE)
if (sys_cfg__is_radio_retry_allowed() == TRUE)
if (intermediate_result != 0)
Nu se recomand$ utilizarea variabilelor globale;
daca vor fi utilizate trebuie indeplinite urm$toarele
cerine:
Toate variabilele globale pentru un proiect vor fi
definite ntr-un singur fi!ier
Variabilele globale vor fi iniializate nainte de
utilizare
O variabil$ global$ va fi definit$ o singur$ dat$
pentru un program executabil
Conven&ii de programare: Includerea
fi#ierelor
Fi!ierele antet vor defini o constant$ simbolic$
pentru a permite includerea multipl$. Dac$ fi!ierul se
nume!te file.h constanta se poate numi FILE_H
"example.h"
#ifndef EXAMPLE_H
#define EXAMPLE_H
#endif
Se recomand$ ca fi!ierele antet s$ nu includ$ alte
fi!iere antet
Pentru includerea unui fi!ier antet definit de utilizator
se vor utiliza , iar pentru o bibiloteca standard < >
Conven&ii de programare: Macrouri
In macrourile tip funcie parametrii vor fi scri!i ntre
paranteze
Nerecomandat
#define prt_debug(a, b) printf("ERROR: %s:%d, %s\n", a,
__LINE__, b);
Recomandat
#define prt_debug(a, b) printf("ERROR: %s:%d, %s\n", (a),
__LINE__, (b));
Macrourile complexe vor fi comentate
Un macrou nu va dep$!i 10 linii
Conven&ii de programare: Stil de
programare
Se va scrie o singur$ instruciune pe linie
Tipul unei funcii !i numele acesteia vor fi pe aceea!i
linie
Nerecomandat
int
err_msg(int error_code)
{
}
Recomandat
int err_msg(int error_code)
{
}
Stil de programare - Spa&ierea
1. Nu vor fi spaii albe:
dupa un cast explicit de tip
Nerecomandat
int x = 1;
double y = 3.0;
y = (double) x + 16.7;
Recomandat
int x = 1;
double y = 3.0;
y = (double)x + 16.7;
ntre operatorii unari (&, *, -, ~, ++, --, !, cast, sizeof)
!i operanzii lor
nainte sau dup$ operatorii primari ( (),[],.,->)
2. Nu vor fi spaii albe:
ntre caracterul # !i directiva de preprocesare
Nerecomandat
#
define TEST 0
sau
# define TEST 0
Recomandat
#define TEST 0
ntre numele unei funcii !i paranteza care i urmeaz$
ntre primul argument al funciei !i paranteza deschis$
ntre ultimul argument al funciei !i paranteza nchis$
Nerecomandat
just_return ( arg1, arg2 );
Recomandat
just_return(arg1, arg2);
ntre parantezele deschis$, respectiv nchis$ !i expresia unei
instruciuni condiionale
if (x == y)
3. Un singur spaiu
va exista ntre expresia condiional$ a unei instruciuni !i
instruciune
Nerecomandat
if(x == y)
Recomandat
if (x == y)
precede !i urmeaz$ operatorii de atribuire, operatorii
relaionali,operatorii logici, operatorii aritmetici (excepie cei
unari) operatorii pe bii !i operatorul condiional
a = 3;
va urma unei virgule
int a, b, c;
Va exista cel puin o linie goal$ care s$ separe definirea
variabilelor locale de instruciuni
int just_return(int first_arg, int second_arg)
{
/*-------------- LOCAL VARIABLES -------------*/
int i = 0; /* Loop counter. */
int j = 0; /* Loop counter. */
/*-------------------- CODE ------------------*/
/*
* Body of funcion just_return.
*/
return(0);
}
Membrii unei structuri, uniuni, enumer$ri vor fi plasai pe linii
distincte la declararea lor
Utilizarea acoladelor #i parantezelor
Componentele logice ale unei expresii condiionale vor fi
grupate cu paranteze chiar dac$ acestea nu sunt necesare
if ((x == y) && (a == b))
Toate acoladele vor fi cte una pe linie
for (i = 0; i < loop_cntrl; i++)
{
/* Body of for. */
}
Toate instruciunile condiionale vor folosi acolade pentru
identificarea corpului acestora chiar dac$ acesta este format
dintr-o singur$ instruciune
if (printf_debug_info == TRUE)
{
printf(%s, debug_info);
}
Indentarea
Toate definiiile de funcii ncep n coloana 1
Acoladele ce definesc corpul unei funcii vor fi n
coloana 1
Acoladele corespunz$toare unei instruciuni, unei
iniializ$ri de structur$, vector, etc vor fi n aceea!i
coloan$ cu instruciunea sau iniializarea respectiv$
for (i = 0; i < loop_cntrl; i++)
{
/* Body of for. */
}
Toate blocurile incluse n alt bloc vor fi indentate cu
2 pn$ la 4 spaii albe
Indentarea
Vor fi indentate cu 2 - 4 spaii:
cmpurile unui tip de date
struct example_type
{
int x;
double y;
};
ramurile case ale unei instruciuni switch
continuarea unei linii, fa$ de operatorul de atribuire sau fa$ de
paranteza deschis$ n cazul unei instruciuni sau a unui apel de
funcie
num = this_example_test_structure.example_struct_field1 *
this_example_test_structure.example_struct_field2;
if ((very_long_result_variable_name >=
lower_specification_value))
Indentarea
Instruciunile aflate la acela!i nivel de includere vor fi
indentate la aceea!i coloan$
if (condiion1 == TRUE)
{
/* Body of if. */
}
else
if
{
/* Body of second if. */
}
else
{
/* Body of else. */
}
Comentarii
Vor completa codul, nu l vor dubla!
Explic$ mai mult dect este subneles din cod
Nu trebuie s$ fie foarte multe comentarii
(ngreuneaz$ codul) dar nici foarte puine (nu este
explicat codul)
Pot fi comentarii bloc, pe o linie, sau in-line
Comentarii
Comentarii bloc: descriu seciunile principale ale
programului !i vor fi indentate la acela!i nivel cu
codul pe care il comenteaz$
/*
* This is one format which can be
* used for block comments.
*/
/**********************************************************
*
* This is also an acceptable format for block comments.
*
**********************************************************/
/*
*********************************************************
*
* This is also an acceptable format for block comments.
*
*********************************************************
*/
Comentarii
Comentarii pe o linie
Se indenteaz$ la acela!i nivel cu codul pe care l
comenteaz$
if (argc > 1)
{
/* Get input file from command line. */
if ((freopen(argv[1], r, stdin) == NULL)
{
/* Body of if. */
}
}
Comentarii in-line (pentru descrierea declaraiilor)
Trebuie s$ fie indeajuns de scurte nct s$ intre pe aceea!i
linie cu codul comentat
int i = 0; /* Loop counter. */
int status = TRUE; /* Return value of this funcion.*/
Reguli generale privind comentariile
Comentariile nu vor fi incluse unele n altele
Fiecare variabil$ local$ va avea un comenatriu ce va descrie
utilizarea ei dac$ aceasta nu reiese din nume
Comentariile in-line trebuie s$ fie aliniate pe ct posibil la
stnga n cadrul unei funcii
j = 5; /* Assign j to the starting string position */
k = j + 9; /* Assign k to the ending string position */
Instruciunile condiionale sau buclele complexe (mai mult de
10 linii necomentate) vor avea ata!at un comentariu la acolada
de nchidere ce va indica nchiderea instruciunii !i unul la
nceputul sau n interiorul blocului ce va indica scopul acestuia
if (a>b){
/* purpose
.
.*/
} // end of if(a>b)
Exerci&iu:
1. S$ se rescrie exemplul anterior utiliznd
conveniile de implementare descrise
(identificatori, convenii de stil, etc.)

Curs 13

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curs 13

Încărcat de

Drepturi de autor:

Formate disponibile

Programarea calculatoarelor

S-ar putea să vă placă și