Что будет если добавить элемент в кольцевой буфер n+1 больший, чем размер буфера?

using namespace std;
#include<iostream> 
class CircularBuffer {
private:
    int* _data;          // Хранимые данные.
    int     _size;          // Размер циклического буффера.
    int     _freeSpace;     // Свободное метос в буффере.
    int     _occupiedSpace; // Занятое мето.
 
public:
    CircularBuffer();
    ~CircularBuffer();
 
    // Метод, возвращающий свободное место.
    int GetFreeSpace() { return _size - _occupiedSpace; }
 
    // Метод, возвращающий занятое место.
    int GetOccupiedSpace() { return _occupiedSpace; }
 
    // Метод добавления элемента в буффер.
    void Add(int val);
 
    // Метод достающий элемент из очереди (с последующим его выталкиванием).
    int Get();
};
 
int main(int argc, char** argv)
{
    // Создаем экземпляр класса.
    CircularBuffer c;
    int count = 10;
 
    // Заполним очередь от 1 до 10 с выводом текущего стояния буффера.
    for (int i = 1; i <= count; ++i) {
        c.Add(i);
        cout << "Fress space: " << c.GetFreeSpace() << "; Occupied: " << c.GetOccupiedSpace() << endl;
    }
 
    // Очистим очередь от 1 до 10 с выводом текущего стояния буффера.
    for (int i = 0; i < count; ++i) {
        cout << "Get next: " << c.Get() << endl;
        cout << "Fress space: " << c.GetFreeSpace() << "; Occupied: " << c.GetOccupiedSpace() << endl;
    }
 
    return 0;
}
 
CircularBuffer::CircularBuffer()
{
    // Инициализация мета под буффер.
    _size = 1024;
    _data = new int[_size];
    // Сборс внутреннего состояния всех полей.
    _freeSpace = _size;
    _occupiedSpace = 0;
}
 
CircularBuffer::~CircularBuffer()
{
    delete[] _data;
} // Не забываем осободить выделенную в конструкторе память.
 
void CircularBuffer::Add(int val)
{
    _data[_occupiedSpace++ % _size] = val;
}  // Устанавивливаем соотв. элемент согласно правилу заполнения циклического буффера.
 
int CircularBuffer::Get()
{
    // Проверка на пустоту буффера.
    if (_occupiedSpace == 0)
        throw "Buffer is empty";    // Борсаем исключение, в случае попытки вытолкнуть из пустой очереди.
 
    int res = _data[0]; // Запоминаем первостоящего в очереди.
    // Сдвигаем очередь на одну позицию вперед.
    for (int i = 1; i < _occupiedSpace; ++i)
        _data[i - 1] = _data[i];
    // Корректируем размер.
    --_occupiedSpace;
    return res; // Возвращаем первый элемент.
}

class A{
inline static c17 = 17; //объявление или определение ?
static const c = 98;  //объявление или определение ?
}

// C++17
 
struct S
{
  inline static int a = 17; // Определение 
  static const int b = 98; // Объявление, но не определение
};
 
int main()
{
  const int *pa = &S::a; // Все в порядке
 
  int array[S::b]; // Все в порядке - для такого использования определение не нужно
 
  const int *pb = &S::b; // Ошибка линкера - не хватает определения
}

// C++17
 struct S
{
  inline static int a = 17; // Определение 
  static const int b = 98; // Объявление, но не определение
};
 int S::b = 99;
int main()
{
  const int *pa = &S::a; // Все в порядке
   int array[S::b]; // Все в порядке - для такого использования определение не нужно
   const int *pb = &S::b; // 
}

#include <stdio.h>
#include <inttypes.h>
int UDR0 = 32;
 
class Buf  {
    // inline member function should be defined in header
  private:
    typedef uint8_t T;
    const T rx_buffer_size = 16;
    const T rx_mask = rx_buffer_size - 1;
    T rx_buffer[rx_buffer_size] = {0};
    volatile T rx_head = 0;
    volatile T rx_tail = 0;
 
  public:
    inline bool receive() {
      if ((T)(rx_head - rx_tail) < rx_buffer_size) {
        rx_buffer[rx_head++ & rx_mask] = UDR0;
        return true;
      }
      return false;
    }
 
    inline T read() {
      return rx_tail == rx_head ? 0 : rx_buffer[rx_tail++ & rx_mask];
    }
 
};
 
Buf ring;
 
 
int main()
{
    for (;UDR0++ < 42; ) {
        ring.receive();
    }
    
    for (int i=0;i < 10;i++ ) {
        putchar(ring.read());
    }
 
}

struct S
{
  const int i = 42;
};

struct S
{
  const int i;
 
  S() : i(42) {}
};

struct S
{
  const int i = 42;
 
  S() = default;
  S(double) : i(123) {}
  S(int) : i(std::rand()) {}
};