Differenze tra C e C++

Codegrind Team•Aug 23 2024

C e C++ sono due dei linguaggi di programmazione più influenti nella storia dell’informatica. Sebbene C++ sia un’estensione del linguaggio C, esistono differenze sostanziali tra i due, sia in termini di funzionalità che di paradigma di programmazione. Questo articolo esplorerà le principali differenze tra C e C++, mettendo in luce come C++ offra un set di funzionalità più potente e versatile rispetto a C.

Paradigmi di Programmazione

1. Programmazione Procedurale vs. Programmazione Orientata agli Oggetti

C è un linguaggio di programmazione procedurale, il che significa che il focus è su funzioni e procedure per manipolare dati. In C, i programmi sono composti da funzioni che operano su dati passati come argomenti.

// Programmazione procedurale in C
#include <stdio.h>

void saluta() {
    printf("Ciao dal linguaggio C\n");
}

int main() {
    saluta();
    return 0;
}

C++, d’altra parte, supporta sia la programmazione procedurale che la programmazione orientata agli oggetti (OOP). OOP introduce concetti come classi, oggetti, ereditarietà, e polimorfismo, consentendo la modellazione di entità del mondo reale come oggetti con proprietà e comportamenti.

// Programmazione orientata agli oggetti in C++
#include <iostream>

class Saluto {
public:
    void saluta() {
        std::cout << "Ciao dal linguaggio C++" << std::endl;
    }
};

int main() {
    Saluto s;
    s.saluta();
    return 0;
}

2. Astrazione e Incapsulamento

C++ permette una maggiore astrazione grazie alle classi e agli oggetti, che possono incapsulare dati e comportamenti. Questo rende il codice più modulare, riutilizzabile e manutenibile rispetto al C, dove l’incapsulamento è spesso realizzato tramite strutture (struct) e funzioni.

Gestione della Memoria

1. Allocazione Dinamica della Memoria

In C, l’allocazione dinamica della memoria viene gestita tramite le funzioni malloc, calloc, realloc, e free, che fanno parte della libreria standard C. Questo richiede un’attenzione manuale per gestire l’allocazione e la deallocazione della memoria.

// Allocazione dinamica in C
int* arr = (int*)malloc(10 * sizeof(int));
if (arr == NULL) {
    // Gestione dell'errore
}
// Operazioni sull'array
free(arr);

In C++, l’allocazione dinamica può essere gestita con gli operatori new e delete, che sono più intuitivi e offrono una sintassi più semplice per l’allocazione di oggetti e array.

// Allocazione dinamica in C++
int* arr = new int[10];
// Operazioni sull'array
delete[] arr;

2. Smart Pointers

C++ introduce anche i smart pointers (std::unique_ptr, std::shared_ptr, std::weak_ptr), che automatizzano la gestione della memoria riducendo il rischio di memory leaks e problemi di dangling pointers.

#include <memory>

std::unique_ptr<int[]> arr(new int[10]);
// Operazioni sull'array
// La memoria viene automaticamente liberata quando arr esce dallo scope

Funzioni e Overloading

1. Overloading delle Funzioni

C non supporta l’overloading delle funzioni, il che significa che ogni funzione deve avere un nome univoco, anche se esegue operazioni simili su diversi tipi di dati.

C++, invece, supporta l’overloading delle funzioni, permettendo di definire più versioni della stessa funzione che accettano diversi parametri.

// Overloading delle funzioni in C++
int somma(int a, int b) {
    return a + b;
}

double somma(double a, double b) {
    return a + b;
}

2. Funzioni Template

C++ introduce le funzioni template, che permettono di scrivere funzioni generiche che funzionano con qualsiasi tipo di dato, migliorando la flessibilità e la riusabilità del codice.

// Funzione template in C++
template<typename T>
T somma(T a, T b) {
    return a + b;
}

Manipolazione della Memoria e Puntatori

1. Puntatori in C

In C, i puntatori sono strumenti fondamentali per la manipolazione diretta della memoria. Tuttavia, l’uso dei puntatori richiede una gestione manuale e può portare a errori come dangling pointers, memory leaks e buffer overflow.

int x = 10;
int* p = &x;

2. Riferimenti in C++

C++ introduce i riferimenti (&), che sono alias per variabili esistenti e offrono un modo più sicuro e facile da usare per passare variabili alle funzioni senza dover ricorrere ai puntatori.

int x = 10;
int& ref = x;

Inoltre, C++ supporta anche i rvalue references (&&), che sono utilizzati per implementare le move semantics e ottimizzare la gestione delle risorse.

Gestione degli Errori

1. Gestione degli Errori in C

In C, la gestione degli errori è generalmente effettuata tramite codici di ritorno delle funzioni e la variabile errno. Questo approccio richiede controlli manuali dopo ogni chiamata di funzione.

FILE* file = fopen("file.txt", "r");
if (file == NULL) {
    perror("Errore nell'apertura del file");
}

2. Eccezioni in C++

C++ introduce le eccezioni, che offrono un meccanismo più strutturato per la gestione degli errori, permettendo di separare il codice normale dalla gestione degli errori e migliorando la leggibilità del codice.

try {
    throw std::runtime_error("Errore di runtime");
} catch (const std::exception& e) {
    std::cout << "Eccezione catturata: " << e.what() << std::endl;
}

Librerie Standard

1. Libreria Standard di C

C offre una serie di librerie standard (stdlib.h, stdio.h, string.h, etc.) che forniscono funzioni di utilità per la manipolazione di stringhe, input/output, gestione della memoria, e altro. Tuttavia, le funzionalità offerte sono più limitate rispetto a quelle di C++.

2. Standard Template Library (STL) di C++

C++ include la Standard Template Library (STL), che offre una vasta gamma di algoritmi e strutture dati generici come vettori, liste, mappe e set. La STL consente di scrivere codice altamente riutilizzabile e robusto.

#include <vector>
#include <algorithm>

std::vector<int> v = {1, 2, 3, 4, 5};
std::reverse(v.begin(), v.end());

Ereditarietà e Polimorfismo

1. Ereditarietà

C non supporta l’ereditarietà, il che limita la capacità di riutilizzare e estendere il codice.

C++ supporta l’ereditarietà, permettendo di creare gerarchie di classi e riutilizzare codice esistente.

class Base {
public:
    void funzioneBase() {
        std::cout << "Funzione nella classe base" << std::endl;
    }
};

class Derived : public Base {
public:
    void funzioneDerived() {
        std::cout << "Funzione nella classe derivata" << std::endl;
    }
};

2. Polimorfismo

C++ supporta anche il polimorfismo, permettendo di trattare oggetti di classi diverse in modo uniforme attraverso puntatori o riferimenti a classi base.

class Base {
public:
    virtual void funzione() {
        std::cout << "Funzione della classe base" << std::endl;
    }
};

class Derived : public Base {
public:
    void funzione() override {
        std::cout << "Funzione della classe derivata" << std::endl;
    }
};

Base* obj = new Derived();
obj->funzione(); // Chiama la funzione della classe derivata

Conclusione

C e C++ condividono molte somiglianze, ma C++ offre una serie di funzionalità avanzate che lo rendono un linguaggio più potente e versatile. La capacità di supportare la programmazione orientata agli oggetti, insieme a strumenti più sofisticati per la gestione della memoria, la manipolazione dei dati e la gestione degli

errori, rende C++ una scelta preferibile per lo sviluppo di software complessi. Tuttavia, C rimane una scelta popolare per applicazioni di basso livello dove il controllo diretto sull’hardware e la semplicità sono cruciali. Comprendere le differenze tra questi due linguaggi permette agli sviluppatori di scegliere lo strumento giusto per ogni progetto.