В чем разница между C++ и C?

Разница между C++ и C

Это два мощных языка программирования, которые часто используются вместе в системном программировании, но имеют кардинально разные философии и возможности. Давайте разберём основные различия.

1. Парадигма программирования

C — это процедурный язык, ориентированный на императивное программирование:

• Фокус на алгоритмах и структурах данных
• Функции как основная единица кода
• Минимализм и прямой контроль

C++ — это мультипарадигменный язык:

• Объектно-ориентированное программирование (ООП)
• Процедурное программирование
• Функциональное программирование (частично)
• Метапрограммирование через шаблоны

2. Объектно-ориентированное программирование (ООП)

В C нет встроенной поддержки ООП:

// C — эмуляция ООП через структуры и функции
struct Animal {
    char name[50];
    int age;
};

void animal_speak(struct Animal* self) {
    printf("%s makes a sound\n", self->name);
}

void animal_print(struct Animal* self) {
    printf("Name: %s, Age: %d\n", self->name, self->age);
}

В C++ ООП встроено в синтаксис:

// C++ — полноценные классы
class Animal {
private:
    std::string name;
    int age;
    
public:
    Animal(const std::string& n, int a) : name(n), age(a) {}
    
    virtual void speak() const {
        std::cout << name << " makes a sound" << std::endl;
    }
    
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() const override {
        std::cout << name << " barks" << std::endl;
    }
};

3. Управление памятью

Оба языка требуют ручного управления памятью, но C++ предоставляет инструменты:

C — низкоуровневое управление:

// Выделение памяти
int* arr = (int*)malloc(10 * sizeof(int));
char* str = (char*)calloc(100, sizeof(char));

// Очистка памяти (легко забыть!)
free(arr);
free(str);

// Утечка памяти: простая ошибка
int* leaked = (int*)malloc(sizeof(int));
if (error) return;  // Забыли free()!

C++ — RAII и умные указатели:

// RAII (Resource Acquisition Is Initialization)
class FileHandle {
private:
    FILE* file;
    
public:
    FileHandle(const char* name) {
        file = fopen(name, "r");
    }
    
    ~FileHandle() {
        if (file) fclose(file);  // Автоматически вызывается
    }
};

// Умные указатели (автоматическая очистка)
std::unique_ptr<int[]> arr(new int[100]);
std::shared_ptr<std::string> str = std::make_shared<std::string>("Hello");
// Память освобождается автоматически при выходе из области видимости

4. Система типов

C — слабая типизация:

void* generic_function(void* data) {
    // Нужно вручную приводить типы
    int* int_ptr = (int*)data;
    return data;
}

int main() {
    int x = 5;
    generic_function(&x);  // Потеря информации о типе
}

C++ — сильная типизация через templates:

template<typename T>
T process(T data) {
    // Полная информация о типе сохраняется
    // Компилятор генерирует специализированный код для каждого типа
    return data;
}

int main() {
    int x = 5;
    double y = 3.14;
    process(x);  // T = int
    process(y);  // T = double
}

5. Стандартная библиотека

C — минимальная стандартная библиотека (libc):

#include <stdio.h>      // I/O
#include <stdlib.h>     // Утилиты
#include <string.h>     // Строки
#include <math.h>       // Математика
// Всё остальное — третьи библиотеки

C++ — мощная стандартная библиотека (STL):

#include <vector>       // Динамический массив
#include <string>       // Строки
#include <map>          // Ассоциативный массив
#include <algorithm>    // Алгоритмы
#include <memory>       // Умные указатели
#include <iostream>     // I/O
#include <fstream>      // Файловый I/O
#include <thread>       // Многопоточность
// Много других!

6. Переопределение функций (Function Overloading)

C — нет перегрузки функций:

int add_int(int a, int b) {
    return a + b;
}

float add_float(float a, float b) {
    return a + b;
}

// Нужны разные имена для разных типов
int result1 = add_int(5, 3);
float result2 = add_float(5.0f, 3.0f);

C++ — встроенная перегрузка:

int add(int a, int b) {
    return a + b;
}

float add(float a, float b) {
    return a + b;
}

// Одно имя для разных типов
int result1 = add(5, 3);              // Вызовет add(int, int)
float result2 = add(5.0f, 3.0f);     // Вызовет add(float, float)

7. Константность

C — нет эффективной константности:

void process(const int* ptr) {
    // const здесь только соглашение, компилятор не может помешать
    // *(int*)ptr = 10;  // Можно обойти const через каст
}

C++ — полная система const:

class Database {
public:
    // const в конце = функция не меняет объект
    std::string getData() const {
        return data;
    }
    
    void setData(const std::string& d) {
        data = d;  // OK
    }
    
private:
    std::string data;
};

// const гарантируют, что функция не имеет побочных эффектов

8. Исключения

C — нет встроенной обработки ошибок:

int divide(int a, int b, int* result) {
    if (b == 0) {
        return -1;  // Ошибка
    }
    *result = a / b;
    return 0;      // OK
}

int res;
if (divide(10, 2, &res) != 0) {
    printf("Error!");
} else {
    printf("Result: %d", res);
}

C++ — исключения:

int divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("Division by zero");
    }
    return a / b;
}

try {
    int result = divide(10, 0);
} catch (const std::invalid_argument& e) {
    std::cerr << "Error: " << e.what() << std::endl;
}

9. Инициализация

C — инициализация старого стиля:

struct Point {
    int x, y;
};

struct Point p = {10, 20};  // Позиционная инициализация

C++ — гибкая инициализация:

class Point {
private:
    int x, y;
    
public:
    Point(int x, int y) : x(x), y(y) {}  // Конструктор
    Point() = default;                   // Конструктор по умолчанию
};

Point p1(10, 20);           // Вызов конструктора
Point p2{10, 20};           // Uniform initialization (C++11)
Point p3 = {10, 20};        // Бис
std::vector<int> v = {1, 2, 3};  // Инициализатор

10. Производительность

• C — максимальная производительность благодаря минимализму. Часто быстрее благодаря простоте оптимизации.
• C++ — сопоставимая производительность при правильном использовании. Zero-cost abstraction означает, что высокоуровневые конструкции не медленнее низкоуровневого кода.

Сравнительная таблица

Когда использовать каждый язык

Используйте C когда:

• Нужна максимальная простота и контроль
• Работаете с микроконтроллерами или встроенными системами
• Требуется минимальный overhead
• Нужна максимальная portability

Используйте C++ когда:

• Разрабатываете сложные приложения
• Нужна переиспользуемость кода через ООП
• Требуется type-safety
• Работаете в системном программировании высокого уровня

Оба языка остаются актуальными и часто используются вместе в одном проекте: C для критических по производительности частей, C++ для высокоуровневого кода.