小编Tho*_*ell的帖子

我正在调试一个应用程序，出于某种原因（我不太确定），在关闭我的应用程序时abort()被调用。我想尝试找出原因，所以我想在上面放置一个断点，abort()这样我就可以看到堆栈跟踪，并希望发现它被调用的原因，而不是正常退出。

我正在使用 Microsoft Visual Studio 2012（更新 3）并且只有abort()函数的声明（in stdlib.h），因此我无法设置断点。有没有办法解决这个问题？

在我正在编写的应用程序中，我希望每 24 小时备份一次数据，以帮助防止因文件损坏或其他故障而丢失数据的风险。

为此，我使用一个像这样的简单线程：

void BackupThread( const std::atomic<bool>& bTerminateFlag )
{
    std::stringstream ssFilePathAndName;

    while( !bTerminateFlag.load() )
    {
         std::this_thread::sleep_for( std::chrono::hours(24) );

         std::time_t std::chrono::system_clock::to_time_t( std::chrono::system_clock::now() );

         ssFilePathAndName << "\\Backup" << "\\BackupFile-" << std::put_time( std::localtime( &t ), "%Y-%m-%d-%H-%M-%S" ) << ".txt";

         // Save the data using our thread-safe Singleton object:
         g_pManager->Save( ssFilePathAndName.str() );

         ssFilePathAndName.str( "" );
         ssFilePathAndName.clear();
    }
}

然后，我使用对主应用程序类的成员变量的引用来开始此操作：

m_backupThread = std::thread( BackupThread, std::cref( m_bBackupTerminateFlag ) );

但是，我很好奇这是否是处理此过程的坏方法（系统资源方面），因为尽管我已指定线程必须在唤醒前等待 24 小时，但线程可能会在不同的点恢复由调度程序/操作系统检查时间条件，我担心这是否会导致不可忽略的电量或CPU时间被浪费（考虑到这将在系统上持续运行很长一段时间，并且它不会是系统上运行的唯一进程）。

我正在用C++编写一个小型库,我只想在模拟算术类型的情况下实例化模板,我发现了以下问题:

如果我有以下定义Foo:

template<typename T, typename Enable = void>
class Foo;

template<typename T>
class Foo<T, std::enable_if<std::is_arithmetic<T>::value>::type> {
    Foo() = default;
    Foo( const Foo& ) = default;
    ~Foo() = default;

    template<typename U>
    Foo( std::initializer_list<U> list )
    {
        static_assert(std::is_convertible<U, T>::value, "Must use an initializer list with type convertible to T");

        for( std::size_t s = 0; s < 10; ++s )
        {
            tArray[s] = static_cast<U>(list[s]);
        }
    }

private:
    T       tArray[10];
};

我尝试按如下方式初始化它:

int main()
{
    Foo<int> test{ {1, 2, 3, 4, 5, …

我正在编写一个数据库,我希望为特定类型的每个项目分配一个唯一的ID(用于内部数据管理).但是,数据库预计会运行很长时间(理论上无限),并且条目的周转率很高(因为条目被删除并定期添加).

如果我们将我们的唯一ID建模为a unsigned int,并假设数据库中始终存在少于2^32 - 1(我们不能0用作唯一ID)条目,我们可以执行以下操作:

void GenerateUniqueID( Object* pObj )
{
    static unsigned int iCurrUID = 1;
    pObj->SetUniqueID( iCurrUID++ );
}

但是,这很好,直到条目开始被删除,其他的添加到它们的位置,可能仍然少于2^32-1条目,但我们可能溢出iCurrUID并最终分配已经被使用的"唯一"ID.

我有一个想法是使用a std::bitset<std::numeric_limits<unsigned int>::max-1>然后遍历它来找到第一个免费的唯一ID,但是这将具有高内存消耗并且将线性复杂度找到一个免费的唯一ID,所以我正在寻找更好的方法,如果一个存在？

提前致谢!

我知道将数据类型更改为64位整数而不是32位整数将解决我的问题; 但是,因为我在Win32环境中工作,并使用列表(DWORD_PTR32位),我正在寻找替代解决方案.此外,数据通过网络发送,我试图通过使用更小的唯一ID来减少带宽消耗.

我今天正在重写我的一些旧代码以优化它并使其更易读(因为其中一些非常粗略地注释)并且我想知道这些代码块之间是否存在任何技术性能差异:

if( cond1 )
{
     // Do something.
}
else if( cond2 )
{
     // Do something else.
}

和:

if( cond1 )
{
     // Do something.
}
else 
{
     if( cond2 )
     {
          // Do something else.
     }
}

我告诉自己应该没有性能成本,因为应该进行相同数量的比较,但我只是好奇是否有一些我忽略的东西.