Что будет если добавить элемент в кольцевой буфер 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; // Возвращаем первый элемент.
}

template<typename T = uint8_t, const uint8_t rx_buffer_size = 16, typename index_t = uint8_t>
class USART {
 
private:
  T rx_buffer[rx_buffer_size] = {0};
  volatile index_t rx_head = 0;
  volatile index_t rx_tail = 0;
  static const index_t rx_mask = rx_buffer_size - 1;
 
public:
  USART(){
    begin();
  }
 
  static inline void begin(uint16_t ubrr = 9600, uint8_t format = 6, bool u2x = 1){
    /* USART Initialization */ 
  }
  
  static inline void rxc_interrupt(){
    // Wait while UDR buffer is empty. RXC0 = 1 has unread data
    while (!(UCSR0A & (1 << RXC0)));
    if (UCSR0A & (1 << UPE0)){
      // If Parity error, read and discard byte
      UDR0;
    } else {
      // Read and send to RX buffer
      rx_buffer_write(UDR0);
    }
  }
 
  inline bool rx_buffer_write(T c){
    // if (!is_full) write to buffer
    if (rx_head - rx_tail < rx_buffer_size){
      rx_buffer[rx_head++ & rx_mask] = c;
      return true;
    }
    else return false;
  }
 
  inline uint8_t rx_buffer_size(){
    return rx_buffer_size;
  }
 
};
main(){
USART serial;}

    USART<> serial;