Трябва ти автоматична генерация на timerId-тата.

Вариант е да овърлоуднеш:

void TimerManager::startTimer(const int32_t timerId, TimerData&& timerData)

с:

int32_t TimerManager::startTimer(TimerData&& timerData)

В TimerManager при извикването на овърлодната функция ще се генерира timerId, който се връща обратно и може да го запазиш и използваш по-късно за манипулиране на таймера.

Самото генериране може да е прост инкреметиращ брояч, но имай предвид следни особености:

1. Броячите могат да се препълнят. На практика това не би трябвало да се случи - int32_t има над 2 млрд. стойности без да броим отрицателните. 

2. Генерираните ID-та не трябва да съвпадат с тези, които сме задали ръчно отвън. Набързо се сещам за 2 варианта:

• фиксираме range за user defined ID-та (напр. 0 - 1000) и генерираните такива започват след него (напр. от 1001)
• при генериране на ID се проверява дали вече не съществува таймер с такова и ако има се генерира нaново, докато не намерим свободно. Това може да е по-бавно, но подобен подход би решил и проблема с препълването от т.1 - при препълване просто ресетваме брояча и търсим следващата свободна стойност.

Привет, Илиян,

MartinBG ти е дал страхотен отговор.
Аз лично обичам да си имам user defined range от timerId според броя на специфичните обекти.
По този начин имам видимост и пълен контрол на коя част от системата ми, кои id-та използвам.

Това може да се постигне по следния начин:

enum Internals {
  MAX_SNOWFLAKE_TIMERS = 100
}

enum TimerId {
  SOME_TIMER_ID,
  ANOTHER_TIMER_ID,
  SNOWFLAKE_FIRST_TIMER_ID,

  //reserved

  SNOWFLAKE_LAST_TIMER_ID = SNOWFLAKE_FIRST_TIMER_ID + MAX_SNOWFLAKE_TIMERS,
  YET_ANOTHER_TIMER_ID
}

Като ще спазвам ограничението, че мога да имам максимум MAX_SNOWFLAKE_TIMERS активни снежинки.

Относто самите снежинки:
Не е проблем всяка да си има собствен таймер.
Просто трябва да се погрижиш, че този таймер е уникален. Също обекта правилно да стартира/пуска този таймер.

Тук вече си пред архитектурна дилема:
Ако имаш 10-20 снежинки - направи 10-20 обекта с индивидуални таймери.

Ако обаче имаш 50, 100, 1000 обекта - не е ОК да пускаш толкова таймери.
Да приемем, че всичките ти обекти работят на една и съща честота.
Тогава можеш да имаш един обект, който управлява всички снежинки. Той ще има само 1 таймер и когато тикне - ще update-ва всички активни снежинки.

class ParticleHandler {
  void onTimeout(int32_t timerId) {
    if (notMyTimer) return;
    
    for (auto& snowflake : _activeSnowflakes) {
      snowflake.process();
    }
  }

  std::vector<Snowflake> _activeSnowflakes;
}

Ако пък имаш нужда от няколко таймера с различни честоти - просто твоя обект може да управлява няколко таймера като предварително си групира обектите си в контейнери спрямо честотите.
Например:

class Particle {};
class SnowFlake : public Particle {};
class Raindrop : public Particle {};

class ParticleHandler {
  void onTimeout(int32_t timerId) {
    if (timerId == frequentId) {
      for (auto& particle : _frequentParticles) {
        particle->process();
      }
    }
    
    else if (timerId == notSoFrequentId) {
      for (auto& particle : _notSoFrequentParticles) {
        particle->process();
      }
    }
  }

  std::vector<std::unique_ptr<Particle>> _frequentParticles;
  std::vector<std::unique_ptr<Particle>> _notSoFrequentParticles;
}

Поздрави