小编xml*_*lmx的帖子

来自cppref：

笔记

空的shared_ptr（其中use_count() == 0）可以存储可由get()访问的非空指针，例如，如果它是使用别名构造函数创建的。

有可能shared_ptr::use_count() == 0吗shared_ptr::get() != nullptr？

有什么例子可以说明这是真的吗？

通常,代码示例首先:

void f1(int)
{}

#define f2(a) f1(a)

template<class F>
void f3(F f)
{
    f(0);
}

int main()
{
    f3(f2); // error C2065: 'f2' : undeclared identifier
    return 0;
}

由VC++ 2012编译.

我的问题是:

为什么宏扩展遵循模板扩展？我认为这是极端反直觉和容易出错的.

为了简化讨论,我假设只有一个执行线程.以下是我的疯狂猜测:

1,如果CPU从存储器地址读取一个字节,则它可以重复从同一地址读取相同的值.

2,如果CPU重复从端口读取一个字节,则每次可能读取不同的值.

我认为这两种方式的区别在于端口控制器可以在每次读取操作后自动更新端口上的值.

但是,我找不到明确支持我的陈述的任何教科书.

我对么？

我想继承A类,但A的析构函数不是虚拟的,我不能修改A的定义.如何避免以下情况？

struct A
{
    A()
        : a(new char[8])
    {}

    ~A()
    {
        delete[] a;
    }

    char* a;
}

struct B : A
{
    B()
        : A(), b(new char[8])
    {}

    ~B()
    {
        delete[] b;
    }

    char* b;
};

int main()
{
    A* p_a = new B;
    delete p_a; // How to avoid such a dangerous deletion?
}

#include <thread>
#include <chrono>

using namespace std:

void f()
{
    // Sleeping for a very long while
    while (SOCKET s = accept(listening_socket, ...))
    {
         // ...
    }

}

int main()
{
    std::thread t(f);
    DoSomething();
    t.???(); /* What to place here to wake/terminate thread f? */
}

在Win32下,我可以TerminateThread()用来杀死一个线程.但我想要的是一个跨平台的方法来做到这一点.

我应该如何在C++中优雅地做到这一点？

这个问题已经更新.请查看代码.

以下代码是使用VC++ 2012年11月CTP编译的.Scott Meyers的书" Effective C++ "建议我们应该使用这种方法来避免const和非const成员函数的重复.但是,以下代码会导致警告(级别1).因为WDK构建工具将警告视为错误,所以无法成功编译以下代码.

还有其他更好的方法吗？

struct A
{
    int n;

    A(int n)
        : n(n)
    {}

    int Get() const
    {
        return n;
    }

    int Get()
    {
        return static_cast<const decltype(*this)&>(*this).Get();
    }
};

int main()
{
    const A a(8);

    //
    // warning C4717: 'A::Get' : recursive on all control paths,
    // function will cause runtime stack overflow
    //
    a.Get(); 
}

我的编译器是最新的VC++ 2013预览版.(更新了!)

#include <new>

struct A
{
    A(int)
    {}
};

void f(void (*fn)(void*))
{
    A a(0);
    fn(&a);
}

int main()
{
    int n = 0;
    auto fn = [&](void* p)
    {
        //
        // error C2664: 'void f(void (__cdecl *)(void *))' : 
        // cannot convert parameter 1 from 
        // 'main::<lambda_b20f735b061d78dbb0f2f653ecbb482f>' 
        // to 'void (__cdecl *)(void *)'
        //
        new (p) A(n);
    };

    f(fn);
}

为什么不允许这种用法？

这种行为是由标准定义的吗？如果是的话,理由是什么？

#include <iostream>\n\nusing namespace std;\n\nvoid f1()\n{\n    wcout.imbue(locale("chs"));\n    wcout << L"\xe6\x82\xa8" << endl;\n}\n\nvoid f2()\n{\n    locale loc(wcout.getloc(), new codecvt<wchar_t, char, mbstate_t>());\n\n    wcout.imbue(loc);\n    wcout << L"\xe5\xa5\xbd" << endl;\n}\n\nint main()\n{\n    f1(); // OK\n    f2(); // Error. There is no output as expected.\n}\n

根据cplusplus.com的在线文档：

codecvt<wchar_t,char,mbstate_t>: \n\n    converts between native wide and narrow character sets.\n

该程序用VC++编译，在Windows上运行。

本程序中，内部字符集为UCS-2，由VC++编译器定义；外部字符集，即窄字符集，在控制台环境下为GBK（中文字符集）。如果文档属实，则wcout可以将 unicode 字符串从 UCS-2 转换为 GBK f1()；然而，事实并非如此。为什么？

C++ 11标准定义了std::pair如下构造函数:

template<class... Args1, class... Args2>
pair(std::piecewise_construct_t, std::tuple<Args1...> first_args,
     std::tuple<Args2...> second_args);

为什么std::pair采用std::tuplector参数类型而不是const std::tuple&？

如果复制first_args和second_args很重要怎么办？

根据Linux 手册页，Linux C APIopen有两个原型如下：

int open(const char *pathname, int oflags);
int open(const char *pathname, int oflags, mode_t mode);

让我困惑的是：

为什么 Linux C API 'open' 支持函数重载？？