小编Nia*_*all的帖子

在c ++中有没有办法获得"主"程序线程的id？

我看到它std::this_thread::get_id()获取当前正在执行的线程的id但我需要main原始程序线程的id .我没有看到任何功能来获得这个.

原因是我有一些非线程安全的内部函数,只能在应用程序的原始线程上调用,所以为了安全我想做: -

assert(std::this_thread::get_id() == std::main_thread::get_id());

但是当然没有这样做的功能,我看不出任何方法来获取这些信息.

考虑以下代码

int i;

class A
{
public:
   ~A()
   {
       i=10;
   }
};

int foo()
{
   i=3;
   A ob;
   return i;
}

int main()
{
   cout << foo() << endl;
   return 0;
}

既然i是全球性的,我认为这个程序的输出应该是10.ob,当它超出范围会调用应设置的值的析构函数i来10.

示例代码如下:

class A
{
public:
    int k;
    virtual int f();
};
class B:public virtual  A
{
public:
    virtual int a();
};
int main()
{
    cout<<sizeof(A)<<sizeof(B);
}

它打印

8 12

它似乎class B有自己的新虚函数表.

如果class A更改为:

class A
{
public:
    virtual int f();
};

它打印

4 4

谁有人解释原因？

我试图用std::set一组unique_ptr来定义我定义的自定义对象.我在定义集合时提供自定义比较功能(以启用深度比较).在将元素插入集合时,此比较函数似乎正常工作,即具有相同内容的项目未插入两次.

但是,如果我使用比较两个集合operator==,它似乎被忽略,即具有等效元素的集合返回不相等,而我期望(希望)它是相等的(因为我提供的自定义比较函数做了深度比较) .

比较功能是否仅在插入期间使用？如果是这样,是否可以选择进行operator==深入比较？

任何指针赞赏.谢谢 :)

示例代码

//
//  main.cpp
//  Test

#include <iostream>
#include <set>

class Person {
private:
    std::string mName;

public:
    Person(const std::string& name);
    virtual ~Person() {}

    void setName(std::string& name);
    std::string getName();
};

typedef std::unique_ptr<Person> PersonUniquePtr;

Person::Person(const std::string& name)
    : mName{ name }
{
}

void Person::setName(std::string& name)
{
    mName = name;
}   

std::string Person::getName()
{
    return mName;
}

bool isLess(Person* p1, Person* p2)
{
    if (p1->getName().compare(p2->getName()) == -1)
        return …

我希望所有派生的对象都Initable要求terminate()销毁.为此,我创建了一个shared_ptr自定义删除器.

我的问题是我无法访问派生类的受保护的ctor,以便在Initable工厂方法中创建实例.

应该保护ctor,以防止在不使用工厂方法的情况下创建实例.

class Initable {
public:
    virtual void terminate() = 0;

    template<typename T, typename... Ts>
    static shared_ptr<T> make_initable(const Ts &... args) {
        return shared_ptr<T>(new T(std::forward<const Ts>(args)...), [] (Initable * aptr) {
            cout << "custom deleter" << endl;
        });
    }
};

class B : public Initable {
    friend class Initable;
// ...
};

我想避免宣布每个派生阶级的朋友,我该怎么办？

如何序列化boost::serialization包含boost::optional？的类(with )？

即,以下代码在实例化时将给出错误.

错误C2039:'serialize':不是'boost :: optional'的成员C:\ boost\boost_1_55_0\boost\serialization\access.hpp 118

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

class MyClass {
private:
    friend class boost::serialization::access;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & my_member;
    }

    boost::optional<int> my_member;
};

int main() {
    std::ofstream ofs("filename.txt");
    const MyClass g;
    boost::archive::text_oarchive oa(ofs);
    oa << g;
    return 0;
}

我知道可能存在一个更深层次的问题(当值不存在时,你应该写什么文件？),但必须有一些标准的解决方案.我正在寻找解决这个问题的最简单方法.

你会如何转换std::string成BSTR*？

STDMETHODIMP CMyRESTApp::rest(BSTR data, BSTR* restr)
{
    RESTClient restclient;
    RESTClient::response resp = restclient.get(data);

    Log("Response Status code: %s", resp.code);
    Log("Response Body: %s", resp.body);

    *restr = // here
    return S_OK;
}

我需要转换resp.body,然后返回*restr此处.

下面的代码给出了错误:

use of deleted function ‘constexpr B::B(const B&)’

现在,我知道这是因为通过指定移动构造函数(有意)隐式删除了复制构造函数,并且复制向量会导致对(已删除)复制构造函数的调用.我想我也理解为什么使用向量的复制构造函数和赋值运算符.我显然想要使用移动构造函数和赋值运算符:移动对象,因此也移动它包含的向量.那么,如何让我的移动构造函数/赋值运算符使用向量的移动构造函数/赋值运算符？

这是代码:

#include <vector>

class B {
private:
    /* something I don't want to copy */
public:
    B() {};
    B(B&& orig) {/* move contents */};
    B& operator=(B&& rhs) {
        /* move contents */
        return *this;
    };
};

class A {
private:
    vector<B> vec;
public:
    A() : vec() {};
    A(A&& orig) : vec(orig.vec) {};
    A& operator=(A&& rhs) {
        vec = rhs.vec;
        return *this;
    };
};

说我有这些声明:

using fp_type = void(*)();
using fp2_type = void(*)() noexcept;

和

void func(){}
fp_type fp(func);

演员fp2_type(fp)表现良好吗？反过来(将noexcept指定的函数指针强制转换为没有noexcept说明符的函数指针)？

我的任务是在C++类库中迁移错误处理的概念.之前简单返回bool(成功/失败)的方法应该被修改以返回一个Result传达机器可读错误代码和人类可读解释的对象(以及一些在这里无关紧要的解释).

遍历数千行代码是容易出错的,因此我尝试从编译器获得此任务的最佳支持.

我的结果类 - 在其他成员方法中 - 有一个构造函数,它构造了代码的结果和代码的赋值运算符:

class Result
{
    public:
        typedef unsigned long ResultCode;
        explicit Result(ResultCode code); // (1)
        Result& operator=(ResultCode code); // (2)
};

备注:我通常会使用枚举类来ResultCode解决我的问题,但这不是一个选项.这是因为主要的设计目标是Result在不同的库中使用,每个库都应定义自己的结果代码集,而不需要一个大的头文件来定义所有库的所有可能的结果代码.实际上,每个类都应该能够定义本地结果代码,以便可以从类头中获得可能的结果代码列表.因此代码不能枚举Result,它们必须由使用Result类的类定义.

避免隐式转换

return true;

客户端代码中的语句,构造函数已声明为显式.但是在嵌套方法调用中,会出现另一个问题.说,我有一个方法

bool doSomething()
{
    return true;
}

我在一个返回一个Result对象的函数中使用它.我想转发嵌套调用的结果代码

Result doSomethingElse
{
    Result result = doSomething();
    return result; 
}

使用当前实现Result的赋值运算符,这不会给我一个编译器错误 - doSomething()的布尔返回值被隐式转换为unsigned long.

正如我在C++文档中所读到的,只有构造函数和转换运算符可以声明为显式.

我的问题

1. 为什么显式不允许赋值运算符或其他方法？IMO将允许任何方法显式化也很有意义.
2. 是否有其他解决方案可以防止赋值运算符的隐式类型转换？