Riassunto Fondmenti C++

Strutture di controllo in programmazione

La programmazione prevede l'utilizzo di diverse strutture di controllo per gestire il flusso del codice. Le principali sono:

if-else

La struttura if-else permette di deviare il codice verso due o più possibili direzioni, a seconda che una condizione sia vera o falsa.

if (condizione) {
   // Codice da eseguire se la condizione fosse vera
} else {
   // Codice da eseguire se la condizione fosse falsa
}

if

Quando non è necessario specificare cosa accade se la condizione è falsa, è possibile utilizzare la struttura if senza il blocco else.

if (condizione) {
   // Codice da eseguire se la condizione fosse vera
}

switch

La struttura switch permette l'esecuzione condizionata di codice, sulla base del valore di un'espressione intera.

switch (espressione) {
   case const_espressione_1:
      // Blocco di istruzioni 1
      break;
   case const_espressione_2:
      // Blocco di istruzioni 2
      break;
   case const_espressione_n:
      // Blocco di istruzioni n
      break;
   default:
      // Blocco di istruzioni di default
}

L'espressione è un'espressione intera e le const_espressione_i sono costanti intere. Se l'espressione è uguale a const_espressione_i, il programma salta all'inizio del blocco di istruzioni_i. Se l'espressione è diversa da tutte le costanti, viene eseguito il blocco di istruzioni di default.

const_espressione_i salta all'inizio del blocco_istruzioni. Poi esegue tutte le istruzioni fin quando incontra l'espressione break.
#include <iostream>
using namespace std;
int main () {
    // Local variable declaration:
    int a = 10;
    // do loop execution
    do {
        if( a == 15) {
            // skip the iteration.
            a = a + 1;
            continue;
        }
        cout << "value of a: " << a << endl;
        a = a + 1;
    } while( a < 20 );
    return 0;
}

the iteration.
12 a = a + 1;
13 goto loop;
14 }
15 cout << "value of a: " << a << endl;
16 a = a + 1;
17 }
while( a < 20 );
19 return 0;
}

COSTANTI non verranno più cambiate dal programma
const tipo NOME es: const int MIN = 0, MAX = 120;

LEGGERE DALL' INPUT:
#include <iostream>
using namespace std;
int main() {
char letterin; // dichiaro variabile carattere letterin
cout << "Please enter a lower case letter: ";
cin >> letterin; // inserisco ciò che digito nella variabile letterin

FUNZIONI tipo nome_funzione (tipo1 arg1, tipo2 arg2 /*, ecc...*/ ){
... qui il codice ...
return (valore restituito);
}

Devono essere dichiarate prima di essere utilizzate:
tipo nome_funzione (tipo1, tipo2 /*, etc... )

Le funzioni sono richiamate dal programma con il loro nome e lista argomenti.
nome_funzione(arg1, arg2 /*, ecc...*/)
#include <iostream>
using namespace std;
int power(int, int); // DICHIARO LA FUNZIONE POWER
int main() {

const int b = 2;
for (int i = 0; i < 10; i++)
    cout << power(b,i) << '\n'; // RICHIAMO L FUNZIONE POWER CON I DUE ARGOMENTI
return 0;
}

int power(int x, int n){ // SCRIVO COSA DEVE FARE LA FUNZIONE
    int ret = 1;
    for(int i=1; i <= n; i++)
        ret = ret * x;
    return ret;
}

ALLE FUNZIONI VENGONO PASSATE DELLE COPIE DELLE VARIABILI DEL PROGRAMMA PRINCIPALE, QUINDI SE
CAMBIO LE VARIBILI ALL'INTERNO DELL FUNZIONE NON CAMBIERA' NIENTE NEL PROGRAMMA PRINCIPALE.

POSSO USARE & PER PASSARE DIRETTAMENTE LE VARIABILI DAL PROGRAMMA ALLE FUNZIONI SENZA CREARE UNA
COPIA: tipo Nomefunzione (tipo1& arg1, tipo2& arg2 /*, ecc...*/ ){ ... qui il codice .. return (valore di ritorno); }

CONST tipo variabile lo uso per evitare che avvengano modifiche involontarie della variabile

SCAMBIARE DUE VARIABILI uso VOID= la funzione non restituisce nulla (in questo caso scambia solo)

#include <iostream>
using namespace std;

void swap(int&, int&);

uso & per passare i valori di int direttamente dentro la funzione. Dichiaro la funzione swap.

int main(){
    int a = 5, b = 7;
    cout << "a = " << a << "\tb ="<< b << "\n swap \n";
    swap(a,b); // Richiamo la funzione swap
    cout << "a = " << a << "\tb ="<< b << endl; // mando in output a e b dopo aver fatto la funzione
    return 0;
}

void swap (int& x, int& y) { // dico cosa deve fare la funzione swap ( in questo caso scambia a e b)
    int z; // x e y prendono direttamente i valori di a e b, z è variabile temporanea per scambiare
    z = x;
    x = y;
    y = z;
}

LA FUNZIONE è VOID QUINDI NON METTO RETURN ALLA FINE

ARRAY permettono di memorizzare un gran numero di valori in una lista. Un array di dimensione n, è indicizzato da 0 a (n - 1), dove n è una const int:

tipo nome_array[n]
int evn[2]={2,4}

La dimensione deve essere nota subito.

prima che il programma parta!PUNTATORI variabili che contengono l'indirizzo di una variabile.

Dichiarare un puntatore :

int c = 5; // Dichiarazione di un intero
int *p1; // Dichiarazione di un puntatore ad un intero (p1)
p1 = &c; // p1 viene puntato a c

FORMA COMPATTA:

int *p2 = &c; // Si dichiara un puntatore ad un intero (p2) e lo si punta a c
&p1 mi restituisca l'indirizzo di memoria in cui è salvata la variabile c
*p1 mi restituisce il contenuto dell'indirizzo di c (area puntata) quindi 5

MUOVERSI CON UN PUNTATORE IN UN ARRAY

I puntatori possono essere incrementati per muoversi lungo gli array di i blocchi. Poi si può accedere al contenuto con *(pb+i)

ESEMPIO ALFABETO AL CONTRARIO

#include <iostream>
using namespace std;
int main(){
char b[] = "abcdefghijklmnopqrstuvwxyz"; // DICHIARO UN ARRAY b
char *ipc = &b[0]; // PUNTO UN PUNTATORE AL PRIMO ELEMRNTO DELL'ARRAY b[0]
for(int i = sizeof(b) - 2; i>=0; i--) // MI MUOVO CON

UN CICLO FOR: i VA DA 0 ALLA DIMENSIONE DI b E DECREMENTO7 cout << *(ipc+i); SCRIVO LA VARIABILE A CUI PUNTO INCREMENTATA DI 1 OGNI VOLTA8 cout << endl ; sizeof(b) MI LEGGE LA DIMENSIONE DI b9 } L’ULTIMO CARATTERE DI UNA STRINGA E’ /0 QUINDI DEVO METTERE UN -2 PER LEGGERE SOLO LE LETTERESizeof(b)-2ALLOCAZIONE MEMORIASingola Variabile: new tipo; delete puntatoreArray: new tipo array[n]; delete [] nome array#include <iostream>using namespace std;int main()6 {7 int n = 4; //DICHIARO LA DIMENSIONE n8 char* A; //CREO UN PUNTATORE AD UN CARATTERE9 A = new char[n]; //ALLOCO UNA MEMORIA DI GRANDEZZA n (4 bytes)11 for(int i = 0; i < n; i++)12 {13 A[i] = (char)('a' + i); }16 for(int i = 0; i < 4; i++)17 {18 cout << A[i] << endl; }21 delete [] A; LIBERO LA MEMORIA ALLOCATA23 return 0; }STRINGHETipo di classe (variabile). La dichiaro così string nome; le posso sommare così string nome=nome +nome;#include <cstring>2

#include <iostream>
using namespace std;

int main() {
    string a, b;
    a = "Hi there";
    b = "how are you doing";
    string c = a + ", " + b;
    cout << c << endl;

    #include <iostream>
    #include <string>
    #include <cstring>
    using namespace std;

    void toLower(string*);

    int main() {
        string str;
        cout << "Insert one string: ";
        getline(cin, str);
        toLower(&str);
        cout << "String converted to lower case: " << str << endl;
        return 0;
    }

    void toLower(string *s) {
        for (int i=0; i < s->size(); i++){
            if ((...
        }
    }
}

namespace std;
int main()
{
    int n = 2, m = 2;
    char **A;
    A = new char*[n];
    for(int i = 0; i < n; i++)
    {
        A[i] = new char[m];
    }
}