Класс - концентрические окружности

//concentric.h:
#pragma once
 
#include <initializer_list>
#include <iostream>
 
template <typename _Real = float>
class CONCENTRIC {
    _Real _x, _y;
    unsigned _count;
    _Real* _r;
 
    void _Init(const CONCENTRIC& c) {
        delete[ ] _r;
        _x = c._x;
        _y = c._y;
        _r = new _Real[_count = c._count];
        for (unsigned i = 0; i < _count; i++)
            _r[i] = c._r[i];
    }
 
public:
    //Конструктор по умолчанию
    CONCENTRIC(): _x(0), _y(0), r(nullptr), _count(0) { }
 
    //Конструктор
    CONCENTRIC(const _Real& x, const _Real& y, unsigned count = 0): _x(x), _y(y), _count(count) {
        _r = _count ? new _Real[_count] : nullptr;
    }
 
    //Конструктор из списка инициализации
    CONCENTRIC(const std::initializer_list<_Real>& l): _x(0), _y(0) {
        if (_count = l.size()) {
            _r = new _Real[_count];
            unsigned i = 0;
            for (const auto& a: l)
                _r[i++] = a;
        } else
            _r = nullptr;
    }
 
    //Конструктор копирования
    CONCENTRIC(const CONCENTRIC& c) { _Init(c); }
 
    //Конструктор переноса
    CONCENTRIC(const CONCENTRIC&& c): _x(c._x), _y(c._y), _count(c._count), _r(c._r) { }
 
    //Деструктор
    ~CONCENTRIC() { delete[ ] _r; }
 
    //Оператор присваивания
    CONCENTRIC& operator=(const CONCENTRIC& c) { _Init(c); }
 
    //Оператор доступа по индексу
    _Real& operator[ ](unsigned index) { return r[i]; }
    const _Real& operator[ ](unsigned index) const { return r[i]; }
 
    //Оператор вывода в поток
    friend std::ostream& operator<<(std::ostream& os, const CONCENTRIC& c) {
        os << '(' << c._x << "; " << c._y << "):\n";
        if (c._count) {
            os << *c._r;
            for (unsigned i = 1; i < c._count; i++)
                os << ", " << c._r[i];
        }
        return os << endl;
    }
 
    //Методы, получающие и задающие координаты центра
    _Real X() const { return _x; }
    _Real Y() const { return _y; }
    _Real X(const _Real& x) { return _x = x; }
    _Real Y(const _Real& y) { return _y = y; }
 
    //Методы, получающие и задающие размер массива
    unsigned Count() const { return _count; }
    unsigned Count(unsigned ct) {
        if (ct != _count) {
            auto t = _r;
            if (ct) {
                _r = new _Real[ct];
                unsigned len = _count < ct ? _count : ct;
                for (unsigned i = 0; i < len; i++)
                    _r[i] = t[i];
                _count = ct;
            } else {
                _r = nullptr;
                _count = 0;
            }
            delete[ ] t;
        }
        return _count;
    }
};

//main.cpp:
#include "concentric.h"
 
using namespace std;
 
enum { N = 5 };
 
int main() {
    CONCENTRIC c1(2.5, 7.6, N);
    CONCENTRIC c2 = { 1, 2, 3, 4, 5 };
    c2.X(.0);
    c2.Y(.0);
    CONCENTRIC<double> c3(8e-10, 2e-10);
    c3.Count(N);
    for (char i = 0; i < N; i++) {
        c1[i] = i * 2.1;
        c3[i] = i * 1e-10;
    }
    CONCENTRIC c4 = c2;
    c2 = c1;
    cout << c2 << endl << c4 << endl << c3;
}