- Bonjour, je suis étudiant et je cherche à optimiser une classe vecteur en c++.

Pour cela, il me faut implémenter les caractéristiques suivantes :
- Distinction entre l'Allocation/déallocation de stockage et l'initialisation/destruction
-Small Buffer Optimization : On ajoute un buffer de capacité N. Si la taille du vecteur n'excède pas N (vecteur court), on a pas besoin d'allouer dynamiquement le stockage pour les éléments du vecteur. (La Capacité d'un vecteur construit par le constructeur par défaut est N)

Contenu du vecteur :
- Constructeur par défaut
-Constructeur/Opérateur d'attribution de Copie/de Déplacement
-Destructeur
-Fonctions Reserve, Push Back, emplace back,pop back, clear, swap.
-Accès au premier élément, à l'élément i, à la capacité et à la taille du vecteur

Je suis débutant en C++/langages bas niveau et j'ai choisi un cours trop avancé qui fait que, malgré le travail, j'arrive à un point où je suis perdu. J'ai donc besoin de votre aide,
Voici un extrait de mon code, je ne sais pas si il est correct, il comporte les constructeurs/opérateurs d'attribution par défaut et de copie.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
#pragma once
 
 
#include <iostream>
#include <memory>
 
 
 
 
namespace epc{
 
 
template <typename T, size_t N>
class vector
{
private:
    //initialisation des variables
    T* _data;
    size_t _size; 
    size_t _capacity;
    alignas(T) unsigned char m_buffer[N * sizeof(T)]; //initialisation du buffer
 
 
public:
  vector() noexcept : _data(nullptr), _size(0), _capacity(0) {}; //Constructeur par défaut
 
 
// Appel du constructeur par défaut pour s'assurer que le vecteur est bien initialisé.
  explicit vector(std::size_t s) : _size(s), _capacity(s) {
    //Test si la taille est supérieur à la taille du buffer et alloue la mémoire en conséquence
    if (s > N) {
      _data = reinterpret_cast<T*>(::operator new(sizeof(T) * s));
    } else {
      _data = reinterpret_cast<T*>(&m_buffer);
    }
    //Construction par défaut
    for (std::size_t i = 0; i < _size; i++) {
        new(_data + i) T();
    }
}
 
 
// Copy constructor
  vector(const vector &other) : _size(other._size), _capacity(other._capacity) {
    //Test si la taille est supérieur à la taille du buffer et alloue la mémoire en conséquence
    if (other._capacity > N) {
      _data = reinterpret_cast<T*>(::operator new(sizeof(T) * other._capacity));
    } else {
      _data = reinterpret_cast<T*>(&m_buffer);
    }
    //Construction par copie
    for (std::size_t i = 0; i < _size; i++) {
       new(_data + i) T(other._data + i);  
    }
}  
 
//copy assignment operator
    vector &operator=(const vector &other) {
        //Copie la taille et la capacité de la variable rhs
        _size = other._size;
        _capacity = other._capacity;
        //alloue la mémoire en fonction de la taille de la variable rhs
        _data = reinterpret_cast<T*>(::operator new(sizeof(T) * _capacity));
        //Construction par copie
        for (std::size_t i = 0; i < _size; i++) {
        new(_data + i) T(other._data + i);  
        }
        return *this;
    }
 
 
}}


J'aimerais me concentrer sur cette partie d'abord pour être sur de comprendre comment bien implémenter ces constructeurs en gérant le buffer et différencier les cas ou le vecteur est long (taille >N) et celui ou il est court. Y'a t'il des erreurs, de syntaxe, de logique ? Qu'est ce qu'une variable rhs et à quoi elles servent dans ce code ?
Je ne comprend pas cette ligne : _data = reinterpret_cast<T*>(::operator new(sizeof(T) * other._capacity)); Alloue t'elle bien un nouveau buffer plus grand ?

Merci beaucoup pour votre aide.