Programmazione C++

Gianluigi Ciocca, Luigi Celona

Breve storia del C++
Timeline
1966
Martin Richards
Cambridge, MIT BCPL
SIMULA
1969
Ken Thompson B 1967
Bell Laboratories
Ole-Johan Dahl
Kristen Nygaard
Norwegian Computing Centre
1971 NB
Ken Thompson
Bell Laboratories

C
1972 1983-1998
Dennis Ritchie Bjarne Stroustrup
Bell Laboratories
Bell Laboratories
C++

C++03 C++11 C++14 C++17 C++20 C++23

Programmazione C++ 2
Breve storia del C++
Gli antenati - Simula

◆SIMULA
⚫ Basato su Algol60
⚫ Progettato per simulare eventi discreti
▪ Esteso per diventare un linguaggio di programmazione

⚫ Precursore dei linguaggi moderni

▪ Concetto di oggetti e classi
▪ Ereditarietà
▪ Dynamic Binding

⚫ Aspetti negativi
▪ Troppo complicato, poca documentazione
▪ Eseguibili molto grandi
▪ Compilazione monolitica

Programmazione C++ 3
Breve storia del C++
Gli antenati – C

◆C
⚫ Introduzione di un preprocessore
⚫ Compilazione separata dei file
⚫ Astrae l’architettura HW… ma non troppo
▪ Gestione memoria tramite puntatori
▪ Diversi tipi di dati : unsigned, long, enumeration, …
▪ Dati aggregati: union, struct
▪ Conversione di tipo esplicita (cast)
▪ “Portable I/O package” poi diventato “standard I/O library”

⚫ Usato per generare codice altamente performante

▪ Sistemi operativi (Kernel Linux)
▪ Firmware

Programmazione C++ 4
Breve storia del C++
1983: Il C++ (Bjarne Stroustrup) (1)

◆C++
⚫ Piena compatibilità con il C
▪ C++ : superset del C

⚫ Realizzazione di programmi di grandi dimensioni

▪ Introduzione delle classi

⚫ “Blindatura” di alcune cause d’errore nel C

▪ I/O stream library

⚫ Exception handling
⚫ Overloading degli Operatori
⚫ Standard Template Library (STL)

Programmazione C++ 5
Breve storia del C++
1983: Il C++ (Bjarne Stroustrup) (2)

“C++ is designed to be a statically typed, general-purpose language that is as efficient and

portable as C”

“C++ is designed to directly and comprehensively support multiple programming styles:

procedural programming,
modular programming,
object-oriented programming,
generic programming”

Bjarne Stroustrup, “The Design and Evolution of C++”

Programmazione C++ 6
Breve storia del C++
1983: Il C++ (Bjarne Stroustrup) (3)

Procedural programming
“Decide which procedures you want; use the best algorithms you can find.”

double sqrt (double arg) {

// some code
}

void some_function(double v) {

double root2=sqrt(2);

double val=root2*v+1.65;
}

void some_other_function() {
// some code
}

void some_other_function(char c, int i) {

// some code
}

...

Programmazione C++ 7
Breve storia del C++
1983: Il C++ (Bjarne Stroustrup) (4)

Modular programming
“Decide which modules you want; partition the program so that data is hidden within modules.”
utils.h

user.cpp // MyStack Declaration

namespace MyStack {
#include “utils.h” // importa MyStack void push(char);
char pop();
void print() {...} void print();
}
void f() {
MyStack::push(‘a’);
MyStack::push(‘b’);
char c = MyStack::pop();
utils.cpp
MyStack::top=0; // Errore: non è a conoscenza di top // MyStack Definition
// all’interno di MyStack namespace MyStack {
char v[200];
MyStack::print(); //print definto in “utils.cpp” int top=0;
print(); // print definito in “user.cpp”
void push(char c) {...}
} char pop() {...}
void print() {...}
}

Programmazione C++ 8
Breve storia del C++
1983: Il C++ (Bjarne Stroustrup) (5)

Object Oriented programming

“Decide which classes you want; provide a full set of operations for each class; make commonality explicit by using
inheritance.”
// An Abstract (Polymorphic) type
// A Concrete type class Shape {
class complex { // ...
double re, im; public:
public: virtual void draw()=0;
complex(double r, double i) {re=r;im=i} // ...
complex(double r) {re=r;im=0;} };
complex() {re=im=0;}
// A Derived Concrete type
complex operator+(const complex &c) {...} class Circle : public Shape {
complex operator-(const complex &c) {...} // ...
// ... public:
}; void draw(){...}
// ...
};

Programmazione C++ 9
Breve storia del C++
1983: Il C++ (Bjarne Stroustrup) (6)

Generic programming
“Decide which algorithms you want; parameterize them so that they work for a variety of suitable types and data
structures.”
template <class T> class Stack { // A generic concrete type
// ...
public:
void push(T value) {...}
T pop() {...}

T* begin() {...} // pointer to first element in the Stack

T* end() {...} // pointer to past last element in the Stack
// ...
};

// A generic algorithm Stack<int> si;

template <class In, class Out> Stack<double> sd;
void copy (In start, In end, Out to) { char buffer[200];
while (start != end) {
*to = *from; //...
from++;
to++; copy(si.begin(),si.end(),sd.begin());
}
}; copy(si.begin(),si.end(),buffer);

Programmazione C++ 10
Breve storia del C++
1983: Il C++ (Bjarne Stroustrup) (7)

“C++ is designed to give the programmer choice, even if this makes it possible for the
programmer to choose incorrectly”

“C++ is designed to be as compatible with C as possible, therefore providing a smooth

transition from C”

“C++ avoids features that are platform specific or not general purpose”

“C++ does not incur overhead for features that are not used”

“C++ is designed to function without a sophisticated programming environment”

Bjarne Stroustrup, “The Design and Evolution of C++”

Programmazione C++ 11
Breve storia del C++
2011/2014: C++11, C++14

◆Estensioni al Linguaggio
⚫ Multitasking utilities, parallel execution, atomic operations, nullptr constant, delegation, initializer_list,
funzioni lambda, automatic type deduction, ...

◆Estensioni alla Libreria Standard

⚫ Hash table, smart pointer, tuple, espressioni regolari,...

◆Estensioni alla Libreria Matematica

⚫ Random number facilities, new mathematical functions,...

// Type inference
int some_int;
decltype(some_int) other_integer_variable = 5;
auto other_variable = some_function(…);

// Range-based for-loop (foreach)

int my_array[5] = {1, 2, 3, 4, 5};
for (int &x : my_array) { x *= 2; }

// Initializer list
SequenceClass some_var = {1, 4, 5, 6};

Programmazione C++ 12
Breve storia del C++
2017: C++17

◆Estensioni al Linguaggio
⚫ Type deduction per le classi, easy nested namespace, inizializzazioni negli if e switch,…

◆Estensioni alla Libreria Standard

⚫ Nuovi algoritmi, file system library (!), versioni parallelizzate degli algoritmi standard,
std::string_view, std::any, std:any_cast, …

#include <any>
#include <iostream>

// any type
std::any a = 1;
std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\n'; // i: 1
a = 3.14;
std::cout << a.type().name() << ": " << std::any_cast<double>(a) << '\n'; // d: 3.14
a = true;
std::cout << a.type().name() << ": " << std::any_cast<bool>(a) << '\n'; // b: 1 (true)

Programmazione C++ 13
Breve storia del C++
2020: C++20

◆Estensioni al Linguaggio
⚫ Concepts, three-way comparison <=>, modules,…

◆Estensioni alla Libreria Standard

⚫ Ranges, coroutines, new memory management, …

// helloworld.cpp
export module helloworld; // module declaration
import <iostream>; // import declaration
export void hello() // export declaration
{
std::cout << "Hello world!\n";
}

// main.cpp
import helloworld; // import declaration
int main() {
hello();
}

Programmazione C++ 14
C++
Osservazioni: Pro
◆Diversi stili di programmazione
⚫ Lo stile di programmazione giusto per il compito giusto
▪ Da procedurale puro a Object-Oriented puro

◆Alte prestazioni con massima flessibilità

⚫ Scalabilità nell’uso delle varie funzionalità
▪ Garanzia di efficienza

◆Librerie essenziali

◆Portabilità a livello di codice tra diversi sistemi

Programmazione C++ 15
C++
Osservazioni: Contro
◆La massima flessibilità può portare a scrivere codice ibrido

◆Le librerie standard sono limitate

⚫ Per compiti più complessi necessarie librerie specifiche esterne

◆Portabilità limitata dall’uso di librerie che dipendono da una piattaforma

specifica
⚫ Necessario identificare ed isolare accuratamente il codice non portabile incapsulandolo
con una interfaccia indipendente

Programmazione C++ 16
Processo di Compilazione
JAVA

Sorgente .java ... Sorgente .java

Compilatore

Bytecode .class Bytecode .class

JVM - JRE

Class Loader

Just-in-Time
Interpreter
Compiler
Portabilità a livello
di Bytecode

Eseguibile

Programmazione C++ 17
Processo di Compilazione
C/C++
Sorgente .cpp / .cc Sorgente .cpp / .cc

Preprocessore Preprocessore

Unità di Unità di
compilazione ... compilazione

Compilatore Compilatore

Codice .obj / .o Codice .obj / .o

Librerie Linker
Portabilità a livello
di codice sorgente

Eseguibile

Programmazione C++ 18
Processo di Compilazione
Preprocessore (1)

◆Diverse direttive (iniziano con #)

// Macro
#define COSTANTE 12345
// Macro di “funzione”
⚫ #define / #undef #define ADD2(x) x+2

▪ Definisce / Rimuove MACRO o TAG // Tag

#define PIPPO
...
#undef PIPPO

⚫ #if / #ifdef / #ifndef - #else / #elif - #endif #ifdef PIPPO

...
▪ Come if (exp) {...} else {...}; #elif VERSION>2
...
#else
...
⚫ #include #endif

▪ Inclusione di file nel sorgente corrente

#include <file>

Programmazione C++ 19
Processo di Compilazione
Preprocessore (2)
File1 Unità di compilazione:File1

#include “File2” int v1;

#define PIPPO 1234 double v2;
#define FUNZ(a) 2*a+3 char v3;

double d=PIPPO+10; double d=1234+10;

#ifdef PLUTO int j=1000;

int j=900; Preprocessore
#else double k=2*j+3;
int j=1000;
#endif

double k=FUNZ(j);

Al Compilatore
File2 Compilatore

int v1;
double v2; NOTA: #include ha due forme
char v3;
#include “filename”

#include <filename>
Programmazione C++ 20
Processo di Compilazione
Compilatore

◆Operazioni
⚫ Analisi sintattica del codice sorgente
⚫ Analisi semantica
▪ Type Checking
▪ Controllo uso / inizializzazione variabili
▪ Identifica simboli (variabili, funzioni) esterni (senza implementazione)

⚫ Generazione Codice
▪ Allocazione storage
▪ Istruzioni
▪ Inclusione informazioni di debug

⚫ Ottimizzazione Codice
▪ File oggetto (.obj)

Programmazione C++ 21
Processo di Compilazione
Linker

◆Operazioni
⚫ Risolve i riferimenti a simboli (variabili, funzioni) esterni
▪ Cerca nei vari file oggetto l’implementazione
▪ Cerca nelle librerie esterne l’implementazione
▪ Collega (Link) il simbolo con la sua implementazione (indirizzo)
▪ Errore tipico : “Unresolved External Symbol”

⚫ Assembla i vari file oggetto

▪ Creazione del file eseguibile
▪ Aggiunge codice di startup
▪ Assembla nel file finale il codice effettivamente utilizzato/chiamato

⚫ La libreria standard è automaticamente linkata dal linker

Programmazione C++ 22
Processo di Compilazione
I file sorgente

◆Codice strutturato in 2 tipi di file con funzionalità diverse (+o-)

⚫ .cpp
▪ Contengono le definizioni di funzioni, classi, variabili,...
▪ Possono essere visti come file di implementazione di una libreria di funzionalità
▪ Sono compilati separatamente uno dall’altro

⚫ .h
▪ Contengono le dichiarazioni di funzioni, tipi di dati (classi e simili), variabili, ...
▪ Possono essere visti come file di interfaccia di una libreria (es: cosa contiene il corrispondente
.cpp)
▪ Sono inclusi dai file .cpp (e altri file .h) per conoscere l’interfaccia di ciò che viene usato

Programmazione C++ 23
Processo di Compilazione
Esempio di compilazione (1)

file.cpp REGOLA BASE: Per la compilazione, tutto

DEVE essere dichiarato PRIMA del suo uso.

// Funzioni Globali
double f1(double v)
{
...
}

int f2(int v1, int v2)

{
...
// usa f1()
...

// usa f3()
...
}

void f3(int v)
{
...
}
...

Programmazione C++ 24
Processo di Compilazione
Esempio di compilazione (1)

file.cpp REGOLA BASE: Per la compilazione, tutto

DEVE essere dichiarato PRIMA del suo uso.

// Funzioni Globali
double f1(double v)
{ Compilatore genera codice della funzione.
...
}

int f2(int v1, int v2)

{
...
// usa f1()
...

// usa f3()
...
}

void f3(int v)
{
...
}
...

Programmazione C++ 25
Processo di Compilazione
Esempio di compilazione (1)

file.cpp REGOLA BASE: Per la compilazione, tutto

DEVE essere dichiarato PRIMA del suo uso.

// Funzioni Globali
double f1(double v)
{ Compilatore genera codice della funzione.
...
}

int f2(int v1, int v2)

{
...
// usa f1() Compilatore genera codice per una chiamata
... a funzione.
// usa f3()
...
}

void f3(int v)
{
...
}
...

Programmazione C++ 26
Processo di Compilazione
Esempio di compilazione (1)

file.cpp REGOLA BASE: Per la compilazione, tutto

DEVE essere dichiarato PRIMA del suo uso.

// Funzioni Globali
double f1(double v)
{ Compilatore genera codice della funzione.
...
}

int f2(int v1, int v2)

{
...
// usa f1() Compilatore genera codice per una chiamata
... a funzione.
// usa f3() Errore!
...
} Il compilatore deve conoscere “che faccia ha” f3
prima del suo uso.
void f3(int v)
{
... Al compilatore basta la signature (dichiarazione).
} Non necessaria l’implementazione (definizione).
...

Programmazione C++ 27
Processo di Compilazione
Esempio di compilazione (2)

file.cpp

double f1(double v);

int f2(int v1, int v2);
void f3(int v);

// Funzioni Globale Dichiaro subito quali funzioni ci sono nel .cpp

double f1(double v)
{
...
}

int f2(int v1, int v2)

{
...
// usa f1()
...

// usa f3()
...
}

void f3(int v)
{
...
}
...

Programmazione C++ 28
Processo di Compilazione
Esempio di compilazione (2)

file.cpp

double f1(double v);

int f2(int v1, int v2);
void f3(int v);

// Funzioni Globale Dichiaro subito quali funzioni ci sono nel .cpp

double f1(double v)
{
...
}

int f2(int v1, int v2)

{
...
// usa f1()
...

// usa f3()
...
}
Compilatore genera codice per una chiamata
void f3(int v)
{ a funzione.
... Il linker realizzerà il collegamento effettivo
} con il codice.
...

Programmazione C++ 29
Processo di Compilazione
Esempio di compilazione (3)

file.cpp file.h

#include “file.h” // signature (dichiarazioni)

// di funzioni che voglio far
// Funzioni Globale // conoscere ad un file .cpp
double f1(double v)
{ double f1(double v);
...
} int f2(int v1, int v2);

int f2(int v1, int v2) void f3(int v);

{
... ...
// usa f1()
...

// usa f3()
...
}

void f3(int v)
{
...
}

...

Programmazione C++ 30
Processo di Compilazione
Esempio di compilazione (4)

ops.h

double radice(double v);

file.h ...
ops.cpp
file.cpp #include “ops.h”

#include “file.h” double radice(double v)

#include “ops.h” { ...}
#include “io.h”

...

int f(int v1, int v2)

io.h
{
... void stampa(double v);
radice(10) ...
stampa(20) io.cpp
...
} #include “io.h”
...
void stampa(double v)
{...}

Programmazione C++ 31
Processo di Compilazione
Esempio di compilazione (4)

ops.h

double radice(double v);

file.h ...
ops.cpp
file.cpp #include “ops.h”

#include “file.h” double radice(double v)

#include “ops.h” { ...}
#include “io.h”

...

int f(int v1, int v2)

io.h
{
... void stampa(double v);
radice(10) ...
stampa(20) io.cpp
...
} #include “io.h”
...
void stampa(double v)
{...}

Programmazione C++ 32
Processo di Compilazione
Esempio di compilazione (4)

ops.h

double radice(double v);

file.h ...
ops.cpp
file.cpp #include “ops.h”

#include “file.h” double radice(double v)

#include “ops.h” { ...}
#include “io.h”

...

int f(int v1, int v2)

io.h
{
... void stampa(double v);
radice(10) ...
stampa(20) io.cpp
...
} #include “io.h”
...
void stampa(double v)
{...}

Programmazione C++ 33
Processo di Compilazione
Esempio di compilazione (4)

ops.h

double radice(double v);

file.h ...
ops.cpp
file.cpp #include “ops.h”

#include “file.h” double radice(double v)

#include “ops.h” { ...}
#include “io.h”

...

int f(int v1, int v2)

io.h
{
... void stampa(double v);
radice(10) ...
stampa(20) io.cpp
...
} #include “io.h”
...
void stampa(double v)
{...}

“Segnaposti”/Simboli esterni a chiamate di funzione.

Programmazione C++ 34
Processo di Compilazione
Esempio di compilazione (5)

io.h

file.cpp #include “common.h”

...
io.cpp
#include “io.h”
#include “ops.h” #include “io.h”
... ...

ops.h
common.h
#include “common.h”
...
void xyz();
... ops.cpp
common.cpp
#include “ops.h”
...

...

Programmazione C++ 35
Processo di Compilazione
Esempio di compilazione (5)

io.h

file.cpp #include “common.h”

...
io.cpp
#include “io.h”
#include “ops.h” #include “io.h”
... ...

ops.h
common.h
#include “common.h”
...
void xyz();
... ops.cpp
common.cpp
#include “ops.h”
...

...

Programmazione C++ 36
Processo di Compilazione
Esempio di compilazione (5)

io.h

file.cpp #include “common.h”

...
io.cpp
#include “io.h”
#include “ops.h” #include “io.h”
... ...

ops.h
common.h
#include “common.h”
...
void xyz();
... ops.cpp
common.cpp
#include “ops.h”
...

...

Programmazione C++ 37
Processo di Compilazione
Esempio di compilazione (5)

io.h

file.cpp #include “common.h”

...
io.cpp
#include “io.h”
#include “ops.h” #include “io.h”
... ...

ops.h
common.h
#include “common.h”
...
void xyz();
... ops.cpp
common.cpp
#include “ops.h”
...

...

Programmazione C++ 38
Processo di Compilazione
Esempio di compilazione (5)

io.h

file.cpp #include “common.h”

...
io.cpp
#include “io.h”
#include “ops.h” #include “io.h”
... ...

ops.h
common.h
#include “common.h”
...
void xyz();
... ops.cpp
common.cpp
#include “ops.h”
...

...

Programmazione C++ 39
Processo di Compilazione
Le guardie nel .h (1)

file.cpp io.h common.h

#include “io.h” #include “common.h”

#include “ops.h”
// Contenuto di common.h
// Contenuto di file.cpp // Contenuto di io.h

ops.h

#include “common.h”
Preprocessore

// Contenuto di ops.h

file.cpp

// Contenuto di common.h
// Contenuto di io.h
// Contenuto di common.h
// Contenuto di ops.h
// Contenuto di file.cpp

Programmazione C++ 40
Processo di Compilazione
Le guardie nel .h (2)

file.cpp io.h common.h

#include “io.h” #include “common.h” #ifndef common_H

#include “ops.h” #define common_H

// Contenuto di file.cpp // Contenuto di io.h // Contenuto di common.h

#endif

ops.h

#include “common.h”
Preprocessore

// Contenuto di ops.h

file.cpp

//
//
Contenuto
Contenuto
di
di
common.h
io.h
◆Definizione di guardie nei .h
// Contenuto di ops.h
// Contenuto di file.cpp ⚫ Evita inclusioni multiple

Programmazione C++ 41
Processo di Compilazione
Le guardie nel .h (3)

file.cpp io.h common.h

#include “io.h” #ifndef io_H #ifndef common_H

#include “ops.h” #define io_H #define common_H

// Contenuto di #include “common.h” // Contenuto di common.h

file.cpp #endif
// Contenuto di io.h
#endif

Preprocessore
ops.h

#ifndef ops_H
OGNI FILE “.h”
#define ops_H DEVE AVERE LE
file.cpp #include “common.h” GUARDIE!
// Contenuto di common // Contenuto di ops.h
// Contenuto di io #endif
// Contenuto di ops
// Contenuto di file

Programmazione C++ 42
Processo di Compilazione
Compilazione separata

file.h io.h ops.h common.h

file.cpp #include “common.h” #include void xyz();

... “common.h” ...
#include “file.h” io.cpp ... ops.cpp common.cpp
#include “io.h”
#include “ops.h” #include “io.h” #include “ops.h”
... ... ... ...

◆I quattro file .cpp sono compilati singolarmente e poi linkati nell’eseguibile

finale

◆Se un file .cpp cambia ma non il corrispondente file .h (es. un algoritmo è re-
implementato in modo più efficiente)
⚫ Non è necessario ricompilare gli altri file .cpp

Programmazione C++ 43
Processo di Compilazione
Compilazione separata

◆E’ possibile includere qualunque file con la direttiva #include, anche un .cpp

file.h
file.h io.h
file.cpp
file.cpp #include “common.h”
...
#include “file.h” io.cpp #include “file.h”
#include “io.cpp”
... #include “io.h” #include “io.h”
... ...

...

◆I due file .cpp però NON sono più indipendenti

⚫ E’ come avere un unico file .cpp

Programmazione C++ 44
Processo di Compilazione
”Nascondere” una definizione

ops.h

double funct1(double v);

file.cpp

#include “file.h” ops.cpp

#include “ops.h”
#include “ops.h”

int f(int v1, int v2) double funct2(double v);

{
...
// usa funct1() : OK double funct1(double v)
// usa funct2() : ERRORE {
... // usa funct2 : OK
} }
...
double funct2(double v)
{ ...}

Programmazione C++ 45
Il linguaggio C++
Definizioni e Dichiarazioni
UNA DEFINIZIONE E’
◆ Funzioni ANCHE UNA DICHIARAZIONE

⚫ Definizione

⚫ Dichiarazione

◆ Variabili
⚫ Definizione

⚫ Dichiarazione

Programmazione C++ 46
Il linguaggio C++
Definizioni e Dichiarazioni
UNA DEFINIZIONE E’
◆ Funzioni ANCHE UNA DICHIARAZIONE

⚫ Definizione
tipo_ritorno nome(tipo1 var1, tipo2 var2)
{
// codice
}

⚫ Dichiarazione

◆ Variabili
⚫ Definizione

⚫ Dichiarazione

Programmazione C++ 47
Il linguaggio C++
Definizioni e Dichiarazioni
UNA DEFINIZIONE E’
◆ Funzioni ANCHE UNA DICHIARAZIONE

⚫ Definizione
tipo_ritorno nome(tipo1 var1, tipo2 var2)
{
// codice
}

⚫ Dichiarazione
tipo_ritorno nome(tipo1 var1, tipo2 var2);

◆ Variabili
⚫ Definizione

⚫ Dichiarazione

Programmazione C++ 48
Il linguaggio C++
Definizioni e Dichiarazioni
UNA DEFINIZIONE E’
◆ Funzioni ANCHE UNA DICHIARAZIONE

⚫ Definizione
tipo_ritorno nome(tipo1 var1, tipo2 var2)
{
// codice
}

⚫ Dichiarazione
tipo_ritorno nome(tipo1 var1, tipo2 var2);

◆ Variabili
⚫ Definizione
tipo1 nome1;
tipo2 nome2=valore; // inizializzazione

⚫ Dichiarazione

Programmazione C++ 49
Il linguaggio C++
Definizioni e Dichiarazioni
UNA DEFINIZIONE E’
◆ Funzioni ANCHE UNA DICHIARAZIONE

⚫ Definizione
tipo_ritorno nome(tipo1 var1, tipo2 var2)
{
// codice
}

⚫ Dichiarazione
tipo_ritorno nome(tipo1 var1, tipo2 var2);

◆ Variabili
⚫ Definizione
tipo1 nome1;
tipo2 nome2=valore; // inizializzazione

⚫ Dichiarazione
extern tipo nome; // definizione esterna all’unità
// di compilazione corrente

Programmazione C++ 50
Il linguaggio C++
Definizioni e Dichiarazioni

◆Dichiarazioni multiple non danno mai errore

◆Definizioni multiple danno (quasi) sempre errore

⚫ Generano ambiguità nel linker

file1.cpp file2.cpp

int pippo(double) { int pippo(double) {

... ...
} }

double pluto() {
...
}

double pluto() {
...
}

Programmazione C++ 51
Il linguaggio C++
Riassumendo…

◆Nei file .h
⚫ Dichiarazioni di funzionalità condivise tra diverse unità di compilazione

◆Nei file .cpp

⚫ Dichiarazioni (di comodo) di funzionalità “locali” all’unità di compilazione corrente
⚫ Definizioni / implementazioni delle funzionalità

◆Un file .cpp NON conosce cosa contiene un altro file .cpp fino a che non include
le sue dichiarazioni
◆Mettere sempre le guardie nei file .h

◆NON includere mai un file .cpp in un altro file .cpp

Programmazione C++ 52
Il linguaggio C++
Funzione Main

◆L’entry point del programma è una funzione globale “main”

⚫ Deve esistere una ed una sola funzione main
▪ In un qualunque file .cpp

⚫ Può avere diverse forme

▪ Diversi parametri in input
▪ Deve ritornare un int

// Funzione main che non prende parametri

int main() // o main(void)

{

// corpo del programma

return 0; // 0 se non ci sono errori

}

Programmazione C++ 53
Il linguaggio C++
Input/Output base (std::cout)

◆ “Hello World” in C++

⚫ Scriviamo il testo su console
⚫ ‘std::cout’ è un oggetto predefinito per scrivere caratteri sullo standard output
(console)
▪ Bisogna includere il file di libreria <iostream>
▪ ‘std’ è un namespace
▪ Si usa l’operatore ‘<<’

/* Il classico dei classici

“Hello World” */

#include <iostream>

int main()
{
std::cout << “Hello World”; //output su console

return 0;
}

Programmazione C++ 54
Il linguaggio C++
Input/Output base (std::cin)

◆ Input da tastiera
⚫ ‘std::cin’ è un oggetto predefinito per leggere caratteri dallo standard input (tastiera)
▪ Bisogna includere il file di libreria <iostream>
▪ Si usa l’operatore ‘>>’

#include <iostream>

int main()
{
int numero;

std::cin >> numero; // input da console

std::cout << “Il Numero inserito e’ : ” << numero << std::endl;

return 0;
}

Programmazione C++ 55
Il linguaggio C++
Input/Output base (std::cerr)

◆ Output d’errore
⚫ ‘std::cerr’ è un oggetto predefinito per scrivere caratteri sullo standard error stream
(console)
▪ Bisogna includere il file di libreria <iostream>
▪ Si usa l’operatore ‘<<’

#include <iostream>

int main()
{
std::cerr << “Errore!”; //output su console

return 0;
}

Programmazione C++ 56
Il linguaggio C++

◆ Rimuovere il namespace ‘std::’

⚫ Utilizzare “using namespace std;”
▪ Da usarsi SOLO nei .cpp

#include <iostream>
using namespace std;

int main()
{
int numero;

cout << “Inserire un numero : ”;

cin >> numero;

//output su console con fine riga

cout << “La meta’ del numero inserito e’ : ”<< numero/2.0 << endl;

return 0;
}

Programmazione C++ 57
Le librerie del C++
Standard (1)

◆I file header delle librerie C (elementi definiti nel global namespace)

⚫ <math.h> / <string.h> / ...

#include <math.h>
...

sqrt(10); // Ok

std::sqrt(10); // Errore
...

Programmazione C++ 58
Le librerie del C++
Standard (2)

◆I file header delle librerie C -> C++ (elementi definiti sia nel global namepace
che in std)
⚫ <cmath> / <cstring> / ...

#include <cmath>
...

sqrt(10); // Ok

std::sqrt(10); // Ok
...

Programmazione C++ 59
Le librerie del C++
Standard (3)

◆I file header delle librerie C++ (elementi definiti nel namespace std)
⚫ <iostream> / <string> / ...

#include <string>
...

string s; // Errore

std::string ss; // Ok
...

Programmazione C++ 60
Le librerie del C++
Standard Template Library

◆Containers

◆Algoritmi generici sui containers

◆Iteratori

◆I file header della STL

⚫ <vector> / <algorithm> / ...

#include <vector>
...

vector<int> v; // Errore

std::vector<int> vv; // Ok
...

Programmazione C++ 61