C++ 20: Programmation Système Haute Performance

C++ 20: Programmation Système Haute Performance

C++ reste le langage de choix pour les applications haute performance. Voici comment utiliser les features modernes.

Setup et First Program

#include <iostream>

int main() {
std::cout << "Hello, World!" << std::endl;
return 0;
}

# Compiler
g++ -std=c++20 main.cpp -o main

# Exécuter
./main

Types et Variables

#include <iostream>
#include <string>
#include <vector>

int main() {
// Types primitifs
int age = 25;
double price = 19.99;
bool isActive = true;
char letter = 'A';

// Strings
std::string name = "Jean";

// Collections
std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<std::string> names = {"Alice", "Bob", "Charlie"};

// Auto (type inference)
auto result = 10 + 20; // int

// Const
const int MAX_AGE = 150;

return 0;
}

Classes et Objets

#include <string>
#include <iostream>

class User {
private:
int id;
std::string name;
int age;

public:
// Constructor
User(int id, const std::string& name, int age)
: id(id), name(name), age(age) {}

// Getters
int getId() const { return id; }
std::string getName() const { return name; }
int getAge() const { return age; }

// Setters
void setAge(int newAge) {
if (newAge >= 0 && newAge <= 150) {
age = newAge;
}
}

// Methods
void display() const {
std::cout << name << ", " << age << " ans" << std::endl;
}

// Destructor
~User() {
std::cout << "User " << name << " destroyed" << std::endl;
}
};

// Utilisation
int main() {
User user(1, "Jean", 30);
user.display();
return 0;
}

Smart Pointers (C++11+)

#include <memory>
#include <iostream>

class Resource {
public:
Resource() { std::cout << "Resource created" << std::endl; }
~Resource() { std::cout << "Resource destroyed" << std::endl; }
};

int main() {
// unique_ptr: ownership unique
{
std::unique_ptr<Resource> res(new Resource());
// res.release() ou res.reset()
} // Automatiquement détruit

// shared_ptr: référence comptée
{
std::shared_ptr<Resource> res1 = std::make_shared<Resource>();
{
std::shared_ptr<Resource> res2 = res1;
// res1 et res2 partagent
} // res2 destroyed
} // res1 destroyed

return 0;
}

Ranges et Algorithms (C++20)

#include <vector>
#include <ranges>
#include <iostream>
#include <algorithm>

int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// Filter (C++20)
auto even = numbers
| std::views::filter([](int n) { return n % 2 == 0; });

for (int n : even) {
std::cout << n << " "; // 2 4 6 8 10
}

// Transform
auto doubled = numbers
| std::views::transform([](int n) { return n * 2; });

// Combining
auto result = numbers
| std::views::filter([](int n) { return n > 5; })
| std::views::transform([](int n) { return n * 2; });

return 0;
}

Gestion de la Mémoire

#include <iostream>

int main() {
// Stack (automatique)
int x = 10; // Libéré au fin du scope

// Heap (manuel - à éviter!)
int* ptr = new int(10);
delete ptr; // Oublier = memory leak!

// Modern C++ (RAII)
std::unique_ptr<int> smartPtr(new int(10));
// Automatiquement libéré

return 0;
}

Templates et Generics

template<typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}

// Utilisation
int maxInt = max(10, 20);
double maxDouble = max(3.14, 2.71);

// Template de classe
template<typename T>
class Stack {
private:
std::vector<T> elements;

public:
void push(const T& value) {
elements.push_back(value);
}

T pop() {
T value = elements.back();
elements.pop_back();
return value;
}
};

Exceptions

#include <iostream>
#include <stdexcept>

double divide(double a, double b) {
if (b == 0) {
throw std::invalid_argument("Division par zéro!");
}
return a / b;
}

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

return 0;
}

File I/O

#include <fstream>
#include <iostream>
#include <string>

int main() {
// Écrire
std::ofstream outFile("data.txt");
outFile << "Hello, File!" << std::endl;
outFile.close();

// Lire
std::ifstream inFile("data.txt");
std::string line;
while (std::getline(inFile, line)) {
std::cout << line << std::endl;
}
inFile.close();

return 0;
}

Concepts (C++20)

#include <concepts>

template<typename T>
concept Arithmetic = std::integral<T> || std::floating_point<T>;

template<Arithmetic T>
T add(T a, T b) {
return a + b;
}

// Utilisation
int sum1 = add(5, 10); // OK
double sum2 = add(3.14, 2.71); // OK
// add("hello", "world"); // Erreur de compilation!

Ressources

cppreference: https://en.cppreference.com
C++ Standard: https://isocpp.org
Modern C++: https://modernescpp.com