Introducere în programare - curs și laborator - suport electronic

• %c – citește un caracter
• %d – citește un întreg zecimal
• %i – citește un întreg zecimal
• %e – citește un număr float
• %f – citește un număr float
• %g – citește un număr float
• %o – citește un număr octal fără semn
• %s – citește un sir de caractere
• %x – citește un nr hexazecimal fara semn
• %p – citește un pointer
• %n – argumentul asociat primeste o valoare intreaga egala cu numarul de caractere deja citite
• %u – citeste un numar intreg fara semn
• %[] – scanare pentru set de caractere

• modificatorulh, care poate precede caracterele de conversie d,i,o,u,x,X, precizeaza că valoarea convertită trebuie memorată ca un short int sau unsigned short int;
• modificatorull, care poate precede caracterele de conversie d,i,o,u,x,X, caz în care valoarea trebuie memorată ca un long int sau unsigned long int, sau poate precede caracterele e,E,f,g,G, caz în care valoarea trebuie memorată ca un double;
• modificatorul L, care poate precede numai caracterele e,E,f,g,G și precizează că valoarea convertită trebuie memorată ca un long double.

			scanf("%d%d", &m, &n); 12 34 m=12 n=34
			scanf("%2d%2d", &m, &n); 12345 m=12 n=34 rest: 5
			scanf("%d.%d", &m, &n); 12.34 m=12 n=34
			scanf("%f", &x); 12.34 x=12.34
			scanf("%d%x", &m, &n); 123a m=123 n=0xA
		

• int getchar(void) - citește un caracter de la tastatură. Așteaptă până este apasată o tastă și returnează valoarea sa; tasta apăsată are imediat ecou pe ecran.
• int putchar(int c) - scrie un caracter pe ecran în poziția curentă a cursorului
• fișierul antet pentru aceste funcții este stdio.h.

• char *gets(char *s) – citește caractere din stdin și le depune în zona de date de la adresa s, până la apăsarea tastei <Enter>. În șir, tastei <Enter> îi va corespunde caracterul '\0'.
• dacă operația de citire reușește, funcția întoarce adresa șirului, altfel valoarea NULL ( = 0 ).
• int puts(const char *s) – scrie pe ecran șirul de la adresa s sau o constantă șir de caractere și apoi trece la linie nouă.
• dacă operația de scriere reușește, funcția întoarce ultimul caracter, altfel valoarea EOF (-1).
• fișierul antet pentru aceste funcții este stdio.h

• char *gets(char *s) - primește ca intrare numai un buffer (s), nu știm dimensiunea lui
• poate apărea problema de buffer overflow: citim în s mai mult decat dimensiunea lui, deoarece gets nu ne împiedică, așa că va scrie datele în altă parte

istream &operator >> (TipParametru &)

			#include <iostream.h>
			void main()
			{
				int IntegerNumber;
				cout << "IntegerNumber = ";
				cin >> IntegerNumber;
				cout << "\nWhat you entered = " << IntegerNumber << endl;
			}
		

			#include <iostream.h>
			void main()
			{
				char c;
				while((c = cin.get()) != EOF)
				{
					cout << "c = " << c << endl;
				}
			}
			

• Funcția cin.ignore() se utilizează pentru a trece peste un număr de caractere, până la întâlnirea unui anume caracter: cin.ignore(int NumarMaximDeCaractereIgonorate, char Sfarsit);.
• Funcția cin.peek() returnează următorul caracter din stream, fără însă a-l extrage.
• Funcția cin.putback() inserează în stream un caracter.

• Funcția cout.setf() activează o opțiune de formatare a ieșirii, primită ca parametru: cout.setf(ios::Optiune);, unde Optiune poate fi:
  • showpos - determină adăugarea semnului plus (+) în fața valorilor numerice pozitive;
  • left, right, internal - schimbă alinierea ieșirii;
  • dec, oct, hex - schimbă baza de numerație pentru valori numerice;
  • showbase - determină adăugarea identificatorului bazei de numerație în fața valorilor numerice.
• Funcția cout.setw() modifică dimensiunea ieșirii, fiind similară funcției cout.width(): cout.setw(int Dimensiune);

			#include <iostream.h>
			#include <iomanip.h>
			void main()
			{
				int number = 783;
				cout << "number = " << number;
				cout.setf(ios::showbase);
				cout << "number in hexa = " << hex << number;
				cout.setf(ios::left);
				cout << "number in octal, aligned to the left = " << oct << number;
			}
			

instr_expresie ::= { expresie }opt ;

1. Se evaluează expresia.
2. Dacă este o expresie de forma unei instrucțiuni de atribuire, variabila=expresie, atunci variabila primește valoarea expresiei din dreapta, vechea valoare a expresiei pierzându-se.
3. Dacă este o expresie de forma variabila op = expresie, aceasta este echivalentă cu variabila=variabila op expresie, unde op este un operator din mulțimea {+, -, *, /, % }
4. Dacă este o expresie de forma variabila++ sau ++variabila, aceasta este echivalentă cu variabila=variabila+1.
5. Dacă este o expresie de forma variabila-- sau --variabila, aceasta este echivalentă cu variabila=variabila-1.

		a = b;
		a + b + c;
		;
		cout << a;
		sizeof(int);
	

instr_compusa ::= { lista_de_declarații | lista_de_instrucțiuni }0+
		

1. Se execută o singură dată fiecare dintre instrucțiuni/declarații, de sus în jos și de la stânga la dreapta.
2. Nu se revine în vreun fel la una dintre instrucțiunile/declarațiile anterioare.

		{
			int a=3, b=10, c=7;
			a += b += c;
			cout << a << ", " << b <<  ", " << c; // ?, ?, ?
		}
		if (x > y){
			int temp;
			temp = x; x = y; y = temp;
			cout << x << y;
		}
		{
			int a, b, c;
			{
				b = 2; c = 3; a = b += c;
			}
			cout << "a= " << a <

		instr_if ::=  if (<expresie_booleană>)
							{<instructiunea1>;}
		instr_if-else ::= if (<expresie_booleană>)
							{<instructiunea1>;}
						  else
							{<instructiunea2>;}
	

• Expresii aritmetice
• Comparatori:  ==, !=, <, <=, >, >=
• Conectori logici: &&, ||, !

1. Se evaluează (o singură dată) expresie_booleană.
2. Dacă aceasta este adevărată, atunci se execută instrucțiunea1.
3. Dacă nu este adevărată, atunci, dacă este prezentă ramura cu else, se execută instrucțiunea2.

		if(lungime == latime) 
			ariaPatrat = lungime*lungime;
		if (a % 2) if (b % 2) p = 1; else p = 2; // cu cine este grupat acest „else”?
		if(a%2) { if(b%2) p = 1;} else p = 2;
		if (primulNumar < alDoileaNumar) 
			minimul = primulNumar;
		else
			minimul = alDoileaNumar;

		int primul, alDoilea, alTreilea, alPatrulea, maximul;
		if(primul>alDoilea)
			if(alTreilea>alPatrulea)
				if(primul>alTreilea) maximul = primul;
				else maximul = alTreilea;
			else
				if(primul>alPatrulea) maximul = primul;
				else maximul = alPatrulea;
		else
			if(alTreilea>alPatrulea)
				if(alDoilea>alTreilea) maximul = alDoilea;
				else maximul = alTreilea;
			else
				if(alDoilea>alPatrulea) maximul = alDoilea;
				else maximul = alPatrulea;
	

	int main(void){
		float operand1, operand2, rezultat;
		char op;
		cout << "Expresia:(numar operator numar – FARA SPATII)\n";
		cin >> operand1 >> operator >> operand2;
		if(op == '+')
		  rezultat = operand1+operand2;
		else if(op == '-')
		  rezultat = operand1-operand2;
		else if(op == '*')
          rezultat = operand1*operand2;
		else if(op == '/')
          rezultat = operand1/operand2;
		else{
		  cout << "Eroare in scrierea expresiei!";
        return 1;
    }
    cout << "Rezultatul este: " << rezultat << "\n";
    return 0;
}

	switch (expresia)
	{
		case constanta1:
			grupul_de_instrucțiuni_1; [break;] (break este opțional)
		case constanta2:
			grupul_de_instrucțiuni_2; [break;]
	 ...
	[default:
		grup_implicit_de_instrucțiuni] (default este opțional)
	}

• Valorile constantelor trebuie sa fie diferite; ordinea lor nu are importanţă.
• Acoladele ce grupeaza mulţimea case>-urilor sunt obligatorii.
• După fiecare case pot apare mai multe instrucţiuni fără a fi grupate în acolade.

• Se evaluează expresia.
• Dacă ea are valoarea constanta1, atunci se execută grupul_de_instrucțiuni_1, eventual grupul_de_instrucțiuni_2 etc., până la întâlnirea primului break.
• Dacă ea are valoarea constanta2, atunci se execută grupul_de_instrucțiuni_2 etc., până la întâlnirea primului break.
• ...
• În cazul în care expresia nu este egală cu niciuna din variantele constanta1, constanta2 etc, iar grupul_implicit_de_instrucțiuni este prezent, se execută acesta. (acesta trebuie să apară o singură dată, nu neaparat la sfârşit)

	cin >> i;
	switch(i){
		case 1: cout << " 1";
		case 2: cout << " 2";
		case 3: cout << " 3"; // break;// ???
		case 4: cout << " 4";
		default: cout << " blabla! ";
	//3

		3
		  3 4 blabla !
	

		char eval;
		cin >> eval;
		switch (eval) {
			case 'A':
			case 'a': 
			cout << "Excellent: you got an \"A\"!\n";     
			break;
			case 'B':
			case 'b':     
			cout << "Good: you got a \"B\"!\n";     
			break;
		 }
	

		b
		Good: you got a "B"!
	

1. Se evaluează expresia (condiția).
2. Dacă ea este nulă / nu este adevărată, se trece la instrucțiunea_următoare.
3. Dacă este adevărată, se execută instrucțiunea, apoi se reia ciclul, testându-se din nou valoarea de adevăr (!=0) a expresiei ș.a.m.d.
4. Așadar, cât timp expresia este adevărată, se execută instrucțiunea.

	int n, i=1, factorial=1;
	cin>>n;
	while (i++ < n)
		factorial *= i;
	cout<<factorial;

1. Se execută instructiune.
2. Se evaluează conditie, apoi:
   • dacă valoarea sa este nenulă controlul este transferat înapoi, la începutul instrucţiunii do..while;
   • dacă valoarea este nulă se execută instructiunea_urmatoare.

		unsigned long n;
		do {
			cout << "Enter number (0 to end): ";
			cin >> n;
			cout << "You entered: " << n << "\n";
  		} while (n != 0);
		return 0;
	

	Enter number (0 to end): 25
	You entered: 25
	Enter number (0 to end): 36
	You entered: 36
	Enter number (0 to end): 0
	You entered: 0
	

		int main(void){
	    float operand1, operand2, rezultat;
	    char op, raspuns;
	    int ERROR;
	    cout << "Calculator pentru expresii de forma \n operand1 operator operand2\n";
	    cout << "Folositi operatorii + - * / \n";     
		do{
	       ERROR = 0;
	       cout << "Dati expresia: ";
	       cin >> operand1 >> operator >> operand2;
	       switch(op){
	         case '+': rezultat = operand1+operand2; break;
	         case '-': rezultat = operand1-operand2; break;
	         case '*': rezultat = operand1*operand2; break;
	         case '/': if(operand2 != 0) rezultat = operand1/operand2;
	                   else {cout << "Impartire prin zero!\n"; ERROR = 1;}
	                   break;
	         default : {cout << "Operator necunoscut!\n"; ERROR = 1;}
	       }
	       if(!ERROR)
	          cout << operand1 << " " << operator << " " << operand2 << " = " << rezultat;
	       cin.sync();
	       do{cout << "\n Continuati (d/n)?"; raspuns = getchar();
	       } while (raspuns != 'd' && raspuns != 'n');
	  	} while (raspuns != 'n');
		cout << "La revedere!\n";
		return 0;
		}
	

1. Dacă instructiune nu conţine continue şi expr-cond este prezentă, atunci for este echivalent cu:

   		expr-init;
   		while(expr-cond){
   			instructiune;
   		expr-in/decrementare;
   		}
   		instructiunea_urmatoare		
   		

2. Dacă există continue atunci această instrucțiune transferă controlul la expr-in/decrementare.
3. Se evaluează expr-init - în general aceasta se utilizează pentru iniţializarea iteraţiei.
4. Se evaluează expr-cond - în general aceasta este o expresie logică ce se utilizează pentru controlul iteraţiei. Dacă valoarea sa este nenulă (true), se execută corpul buclei (instrucţiune), se evalueaza expr-in/decrementare și controlul este trecut la începutul buclei, fără a se mai evalua expr-init.
5. În general expr-in/decrementare face trecerea la iteraţia următoare: modifică o variabilă ce intră în componenţa lui expr-cond.
6. Procesul continuă până când valoarea expr-cond este nulă (false). Controlul este transferat următoarei instrucţiuni (cea de după for).

		i = 1;
		suma = 0;
		for(;i <= N;++i) suma += i;
	

		i = 1;
		suma = 0;
		for(;i <= N;) suma += i++;
	

		i = 1;
		suma = 0;
		for(;;) suma += i++; // Bucla infinita
	

1. Cea mai simplă și eficientă variantă:

   		int suma(int n)
   		{
   			return n*(n+1)/2
   		}
   		

2. Varianta iterativă (repetitivă)

   		int suma(int n)
   		{
   			int s = 0;
   			int i;
   			for(i=1; i<=n; ++i)
   				s += i;
   			return s;
   		}
   		

3. Varianta recursivă

   		int suma(int n)
   		{
   			if (n==0) 
   				return 0;
   			else
   				return n+suma(n-1);
   		}

			void swap(int x, int y){
			int temp = x; x = y; y = temp;
	  		cout << "x=" << x<< ",y=" << y<< "\n";
			}
			int main(void){
	  		  int a = 2, b = 3;
	  		  swap(a, b);   // x = 3, y = 2
	  		  cout << "a=" << a<< ",b=" <<b <<"\n";
	  		// a = 2, b = 3
			}
		

			void swap(int& x, int& y){
   			int temp = x; x = y; y = temp;
   			cout << "x=" << x<< ",y=" << y<< "\n";
			} 
			int main(void){
			  int a = 2, b = 3;
   			  swap(a, b);   // x = 3, y = 2
   			  cout << "a=" << a<< ",b=" <<b <<"\n";
   			// a = 3, b = 2
			}
		

		#include <stdio.h>
		#include <stdarg.h>
		int suma(int numar_parametri,...) {
			va_list lista_parametri;
			int suma_numere = 0;
			int i;
			va_start(lista_parametri, numar_parametri);
			for (i = 0; i < numar_parametri; i++) {
				suma_numere = suma_numere + va_arg(lista_parametri, int);
			}
			va_end(lista_parametri);
			return suma_numere;
		}
		int main() {
			printf("Suma numerelor 2, 3, 4, 5 = %d\n", suma(4, 2,3,4,5));
			printf("Suma numerelor 5, 10, 15 = %d\n", suma(3, 5,10,15));
		}
	

		#include <stdlib.h>
		#include <stdarg.h>
		#include <string.h>

		char *vstrcat(char *fmt, ...)
		{
			size_t len;
			char *buf;
			va_list argp;
			char *p;

			if (fmt==NULL)
				return NULL;
			len = strlen(fmt);
			va_start(argp,fmt);

			while((p=va_arg(argp, char *)) != NULL)
				len+=strlen(p);

			va_end(argp);
			buf =(char *)malloc(len+1);
			if (buf==NULL)
				return NULL;

			strcpy(retbuf,fmt);
			va_start(argp,fmt);

			while((p = va_arg(argp, char *)) != NULL)
				strcat(buf,p);
			va_end(argp);
			return buf;
		}
	

char *sir = vstrcat("Ghici, cine ","vine ","la cina!",(char *)NULL);