Экземпляры класса внутри другого класса - есть ли способ контролировать количество?

Как указано в комментарии к вашему первоначальному вопросу, шаблон, вероятно, является лучшим решением.

Шаблоны позволяют писать очень гибкий код. Я не буду объяснять почему; это то, что выходит немного за рамки самого вопроса. Однако ниже показано, что вы можете создать шаблон, который означает, что вы можете создать класс buttonArrayTFT с N количеством элементов buttonTFT, если N известно во время компиляции. Ссылка, приведенная в качестве комментария, описывает различные аспекты шаблонов, но не обязательно объясняет, как связать все это вместе.

В разделе Параметры, не относящиеся к типу для шаблонов, вы увидите, что вы можете указать целое число в качестве параметра для создания N элементов переменной-члена массива.

Но как насчет параметра типа, T? Вы можете просто опустить его. На самом деле вам не нужно создавать шаблон для типа.

В вашем файле .h:

template <uint8_t ARRAY_SIZE>
class buttonArrayTFT
{
public:
// One thing to remember about templates: you have to pack the definition
// into the header file with the declaration to avoid all manner of headaches.

    buttonArrayTFT(XPT2046_Touchscreen &_ts = ts, Adafruit_ILI9341 &_tft = tft)
    {
    // Perhaps this is a good opportunity to check that the specified
    // size of the array is sensible, i.e. not zero and no more than 12.
        if ((ARRAY_SIZE == 0) || (ARRAY_SIZE > 12))
        {
            // decide how you want to handle this problem
        }
            // Add the rest of your constructor here
    }

    void create_array(uint8_t R, uint8_t C, char *but_txt[]);
    uint8_t checkPress(TS_Point &p);
        
    // This little piece of magic allows you to access buttonTFT 'x' of the
    // private _buttonArray as if a buttonArrayTFT class was an array
    buttonTFT &operator[](uint8_t index)
    {
    // Check that 'index' is a valid element in the array
        if (index > _num_items)
        {
            // decide how you want to handle this problem
        }
        return _buttonArray[index];
    }
private: 
    buttonTFT _buttonArray [ARRAY_SIZE];
    // I recommend making this constant
    const uint8_t _num_items = ARRAY_SIZE;
};

Я оставлю на ваше усмотрение разобраться с вашими личными, общественными и охраняемыми лицами, и я оставил кнопку _button0; чтобы держать вас в напряжении.

Вы также заметите, что массив, как и раньше, является закрытым, но теперь нет массива указателей на кнопки. Это происходит потому, что в этом нет необходимости; волшебная кнопка и оператор[](индекс int) позволяют вам напрямую обращаться к элементам массива.

В вашем файле .ino или, в зависимости от обстоятельств, вы используете следующий код для создания и последующего использования класса:

buttonArrayTFT<4> myFourButtonArray(/* constructor arguments as required*/);
buttonArrayTFT<12> myTwelveButtonArray(/* constructor arguments as required*/);

Это дает вам два экземпляра класса с соответствующим количеством элементов buttonTFT! Теперь вы можете получить доступ к определенным кнопкам, используя следующий код:

myFourButtonArray[0]; // Возвращает ссылку на первую кнопку
myTwelveButtonArray[10]; // Возвращает ссылку на одиннадцатую кнопку
myFourButtonArray[n] // Возвращает ссылку на "n+1" - ю кнопку

Исходя из предположения, что класс buttonTFT имеет какую-то функцию "чтение", которая возвращает значение TRUE или FALSE для статуса кнопки, вы можете написать:

if (myFourButtonArray[0].read())
{
    // выполняется, если кнопка включена
}
else
{
    // выполняется, если кнопка выключена
}

ПРИМЕЧАНИЕ О ПОСТОЯНСТВЕ:

Перегрузка оператора[], хотя и удивительно волшебная, открыта для злоупотреблений. Однако это ничем не отличается от вашего исходного кода. Массив элементов buttonTFT является закрытым, но есть открытый доступ ко всем кнопкам, как если бы массив не был закрытым. В случае вашего исходного кода можно было бы написать:

myButtonArray._buttons[0] = myButtonArray._buttons[1];

Теперь _buttons[0] указывает на ту же кнопку, что и _buttons[1].

Ой. Теперь myButtonArray._buttons[0]->читать()> буквально то же самое, что и myButtonArray._buttons[1]->читать()>.

Тем не менее, мой код не делает его намного лучше; эквивалентный код:

myFourButtonArray[0] = myFourButtonArray[1];

Просто скопируйте правую сторону на левую сторону. У вас все еще есть два отдельных экземпляра buttonTFT, вероятно, без утечек памяти, но я предполагаю, что класс buttonTFT может содержать ссылку на входной пин, поэтому pin _button[0] теперь будет любым пином _button[1], потому что переменная-член, в которой хранится ссылка на pin, будет перезаписана.

Чтобы устранить эту слабость, просто добавьте классификатор const в начало перегрузки оператора []:

const buttonTFT &operator[](uint8_t index)
{ // };

Теперь элемент buttonTFT не может быть изменен. Это, конечно, вызывает новую головную боль, что все функции, которые полагаются на myArray[n], также должны быть постоянными. Вам решать, как следует интерпретировать постоянную корректность и стоит ли это хлопот.