( bocs | 2022. 09. 30., p – 20:24 )

nézd, ezt kérem leimplementálni C-ben:

std::unordered_map<std::string, std::shared_ptr<Data>> cache;

void AddToCache(std::string dataId, std::shared_ptr<Data> data)
{
  cache[dataId] = data;
}

std::shared_ptr<Data> GetFromCache(std::string dataId)
{
  auto it = cache.find(dataId);
  return it == cache.end() ? {} : it->second;
}

void ClearCache()
{
  cache.clear();
}

Ez ugye egy tetszőleges hosszúságú string kulccsal címezhető O(1) keresési idejű cache implementáció, ami gondosan ügyel a belerakott objektumok élettartamára is (kizárt a memory leak vagy a use after free még akkor is, ha a cache-t kitörlik, miközben valaki használja az ojjektumot).

Nahát ezért használunk magas szintű nyelveket, hogy ne kelljen a triviálissal foglalkozni, hanem a lényegi algoritmusra koncentrálni.
Vagy itt van a következő, ami párhuzamosan lefuttat 4 számolást 4 thread-en.

tf::Executor exec;
tf::Taskflow tasks;

tasks.emplace(
    [] { compute1(); },
    [] { compute2(); },
    [] { compute3(); },
    [] { compute4(); },
  );                                  
                                      
exec.run(tasks).wait();

Ez pontosan ennyi, semmi további kódra nincs szükség, teljesítmény veszteség < 1ms a legnatívabb kézi megoldáshoz képest.

Mivel dolgoztam beágy környezetben is, sokat szenvedtem a régi motorosok szemléletétől, akik ragaszkodtak a C-hez, de minek? A legtöbb helyen eljárt felette az idő.