ИМХО, контора имеет всех необходимых людей и в фоновом режиме ищет "гения, способного выдать в 10 раз больший результат за миску досирака". Если они такого гения найдут (с вероятностью 1e-10, ага), то уволят кого-нибудь из штатных программистов и возьмут на его место гения (одна миска-то дешевле двух).

Кстати, вполне типичное для российских контор явление, когда контора ищет "того, не знаю кого" и отсеивает народ по принципу "хи, что-то не впечатлил". Ибо ни бизнес-плана, ни четких требований к кандидату в конторе нет, а утилизировать рабочее время нанимателей как-то надо.

Опыт работы:
От 1 года до 3 лет 401
От 3 до 6 лет 337
Нет опыта 48
Более 6 лет 26

Visual C++ 2008 (also known as Visual C++ 9.0) was released in November 2007. This version supports .NET 3.5.

Visual C++ 2012 (also known as Visual C++ 11.0) was released on August 15, 2012. It features improved C++11 support, and support for Windows Runtime development.[36]
Visual C++ 2013 (also known as Visual C++ 12.0) was released on October 17, 2013. It features further C++11 and C99 support, and introduces a REST SDK.[37]
Visual C++ 2015 (also known as Visual C++ 14.0) was released on July 20, 2015.[38] It features improved C++11/14/17 support.[39]

BZ>очевидно потому что он якобы включён в стандарт. он же не знает как дела обстоят на самом деле

A __gc type is a C++ language extension that simplifies .NET Framework programming by providing features such as interoperability and garbage collection.

if( demands < 3 )
    demands = 1;
else
    demands -= 2;

    unsigned int m_current_position = 0;
    bool m_current_tick_processed = false;

    lock.unlock();

    while( head )
    {
        try
        {
            ...
        }
        ...
        catch( ... )
        {
            ...
            std::abort();
        }

        head = head->m_next;
    }

    lock.lock();

mgu>>>if( demands < 3 )
mgu>>>    demands = 1;
mgu>>>else
mgu>>>    demands -= 2;
mgu>>>

demands = demands < 3 ? 1 : (demands-2);

mgu>>>    unsigned int m_current_position = 0;
mgu>>>    bool m_current_tick_processed = false;
mgu>>>

my_class::my_class(bla-bla-bla)
  : m_current_position(), m_current_tick_processed(), ...
  {}

class my_class {
  ...
  unsigned int m_current_position{};
  bool m_current_tick_processed{};
};

• эта операция может быть длительной (особенно если таймеров сотни тысяч), в это время нужно позволить параллельно работающим нитям работать с общим списком таймеров (выставлять новые или отменять существующие);
  
• внутри callback-а могут быть свои операции с общим списком таймеров. И такая политика работы позволяет избежать использования recursive_mutex (эффективность работы которого может отличаться от эффективности работы обычного mutex-а).

S>demands = demands < 3 ? 1 : (demands-2);
S>

вы не сталкивались с любовью некоторых программистов обрабатывать ошибки через exit() в библиотечном коде? если функция не может вернуть ошибку (прототип у нее такой) и внезапно обнаружилось, что работая со входным буффером данных функция может его угробить если входные данные были некорректными, а программисту на все наплевать и лишь бы _формально_ выполнить задание вышестоящего программиста -- ну зачем нам думать как протащить обработку ошибок на верхний уровень, когда можно просто завершить работу всего приложения?

bool SMSContentGreater(CSMSContent* pSMS1, CSMSContent* pSMS2) // Global function for std::sort
{
    CTime time1, time2;
    SYSTEMTIME st1, st2;
    if (pSMS1->GetSMSTime().GetAsSystemTime(st1))
        time1 = CTime(st1);
    if (pSMS2->GetSMSTime().GetAsSystemTime(st2))
        time2 = CTime(st2);

    time_t t1 = time1.GetTime();
    time_t t2 = time2.GetTime();

    if (t1 > t2)
        return true;
    else
        return false;
}

CTime ct;
SYSTEMTIME st;
if(pSMS1->GetSMSTime().GetAsSystemTime(st))
  ct = CTime(st);
time_t t1 = ct.GetTime();

if(pSMS2->GetSMSTime().GetAsSystemTime(st))
  ct = CTime(st);
time_t t2 = ct.GetTime();

namespace {
inline time_t GetTime(const CSMSContent & sms) {
  SYSTEMTIME st;
  return sms.GetSMSTime().GetAsSytemTime(st)) ? CTime(st).GetTime() : CTime().GetTime();
}
}

bool SMSContentGreater(CSMSContent * pSMS1, CSMSContent * pSMS2) {
  return GetTime(*pSMS1) > GetTime(*pSMS2);
}

bool SMSContentGreater(CSMSContent * pSMS1, CSMSContent * pSMS2) {
  auto GetTime = [](const CSMSContent & sms) {
    SYSTEMTIME st;
    return sms.GetSMSTime().GetAsSytemTime(st)) ? CTime(st).GetTime() : CTime().GetTime();
  };
  return GetTime(*pSMS1) > GetTime(*pSMS2);
}

CATCmdDevice::CATCmdDevice()
: m_pSerial(NULL), // Added 17.03.2015
  m_bIsGSMDeviceConnected(false) // Added 21.03.2015
{
    m_pTXBuff = NULL;  // Transmitter buffer
    m_pRXBuff = NULL;  // Reciver buffer

    m_bUnicodeMode = false;

    m_pPBRecord = NULL;

    m_bReceivedSMSListFull = false;
}

CATCmdDevice::~CATCmdDevice()
{
    ClearSMSArr(); // Restored 01.10.2014

    if (m_pTXBuff)
    {
        delete[] m_pTXBuff;  
        m_pTXBuff = NULL;
    } 

    if (m_pRXBuff)
    {
        delete[] m_pRXBuff;  
        m_pRXBuff = NULL;
    }
}

long CATCmdDevice::OpenSerial(int iComChannel, int iComBaudRate)
{
    if (m_pSerial)
        delete m_pSerial;

    m_pSerial = new CSerial();
    if (m_pSerial != NULL)
    {   // m_pSerial->Open(1, 9600);
        BOOL bOpen = m_pSerial->Open(iComChannel, iComBaudRate); 
        if(!bOpen)
        {
            g_log.SaveLogFile(PBK_ERROR, "Error during opening port: COM%u (baud rate = %u)",iComChannel,iComBaudRate);
            return 1L; // Error occur
        }
        else
            g_log.SaveLogFile(PBK_DEBUG, "Port: COM%u (baud rate = %u) - opening success!",iComChannel,iComBaudRate);
    }
    return 0L; // OK!
}

    /*!
     * \brief Execute all active timers in the sublist.
     *
     * Object is unlocked and locked back after sublist processing.
     */
    template< class UNIQUE_LOCK >
    void
    exec_actions(
        //! Object lock.
        //! This lock will be unlocked before execution of actions
        //! and locked back after.
        UNIQUE_LOCK & lock,
        //! Head of execution list.
        //! Cannot be nullptr.
        timer_type * head )
    {
        lock.unlock();

        while( head )

    /*!
S>     * \brief Execute all active timers in the sublist.
S>     *
S>     * Object is unlocked and locked back after sublist processing.
S>     */
S>    template< class UNIQUE_LOCK >
S>    void
S>    exec_actions(
S>        //! Object lock.
S>        //! This lock will be unlocked before execution of actions
S>        //! and locked back after.
S>        UNIQUE_LOCK & lock,
S>        //! Head of execution list.
S>        //! Cannot be nullptr.
S>        timer_type * head )
S>    {
S>        lock.unlock();

S>        while( head )
S>

//! Head of execution list.
//! Cannot be nullptr.
timer_type * head )
{
lock.unlock();
while( head )

// Status of timer can be changed. So it must be checked
// just before execution. If timer is waiting for
// deregistration it must not be executed.
if( timer_status::wait_for_execution == head->m_status )
    head->m_action();

The destructor is commonly used to "clean up" when an object is no longer necessary.

if (m_pSerial)
    delete m_pSerial;

m_pSerial = new CSerial();
if (m_pSerial != NULL)
    ....

m_pSerial = new(nothrow) CSerial();

CNewSamsung::CNewSamsung(void)
{
}
CNewSamsung::~CNewSamsung(void)
{
}

mgu> Вам никогда не давали в качестве тестового задания посчитать количество слов в файле?

if(demands < 3)
  demands = 1;
else
  demands -= 2;

demands = demands < 3 ? 1 : demands - 2;

mgu>Н-да... Но бывает гораздо хуже!

if (m_pSerial)
    delete m_pSerial;