相关疑难解决方法(0)

假设我有这个功能:

void my_test()
{
    A a1 = A_factory_func();
    A a2(A_factory_func());

    double b1 = 0.5;
    double b2(0.5);

    A c1;
    A c2 = A();
    A c3(A());
}

在每个分组中,这些陈述是否相同？或者在某些初始化中是否有额外的(可能是可优化的)副本？

我见过有人说过这两件事.请引用文字作为证据.还请添加其他案例.

我想启用 - 字面上 - GCC 所有的警告.(你会觉得这很容易......)

• 你认为-Wall可能会有所作为,但不是!仍然需要-Wextra.

• 你认为-Wextra可能会有所作为,但不是!并非此处列出的所有警告(例如-Wshadow)都已启用.我仍然不知道这份清单是否全面.

我如何告诉海湾合作委员会启用(不是,不是,或者是!)所有警告？

我有两个班,A并且B,每个定义转换B.A有一个转换运算符B,B有一个构造函数A.不应该打电话static_cast<B>暧昧吗？使用g ++,这段代码编译并选择转换构造函数.

#include<iostream>

using namespace std;

struct B;
struct A {
    A(const int& n) : x(n) {}
    operator B() const;         //this const doesn't change the output of this code
    int x;
};

struct B{
    B(const double& n) : x(n) {}
    B(const A& a);
    double x;
};

A::operator B() const           //this const doesn't change the output of this code
{
    cout << "called A's conversion …

嗨我有一个关于this指针的问题,当一个对象被构造时,它何时被初始化？这意味着什么时候可以使用它？虚构表是在构造函数中构造的,与this指针一样吗？

例如,我有一个像这样的代码.输出是8.是否意味着在输入构造函数之前,this指针已经初始化了？

class A{
   public:
     A() { cout<<sizeof(*this);}
     int i;
     int *p; 
};

int main() {      
    A a; 
}

如果是,那么在输入构造函数之前还会发生什么？

如果不是,this指针何时初始化？

我们有这个代码:

Test1 t1;
Test2 t2;
t1 = t2;

我相信有三种(或更多？)方法如何实施 t1 = t2

• 过载赋值运算符 Test1
• 重载类型转换操作符 Test2
• 创建Test1(const Test2&)转换构造函数

根据我的GCC测试,这是使用的优先级:

1. 分配运营商
2. 转换构造函数和类型转换运算符(不明确)
3. const转换构造函数和const类型转换运算符(不明确)

请帮我理解为什么这个优先.

我使用此代码进行测试(取消注释某些行以试用)

struct Test2;
struct Test1 {
  Test1() { }
  Test1(const Test2& t) { puts("const constructor wins"); }
//  Test1(Test2& t) { puts("constructor wins"); }
//  Test1& operator=(Test2& t) { puts("assign wins"); }
};

struct Test2 {
  Test2() { }
//  operator Test1() const { puts("const cast wins"); return Test1(); }
//  operator Test1() { puts("cast …

阅读本文后,我尝试进行以下转换static_cast:

class A;

class B { 
      public: 
         B(){} 

         B(const A&) //conversion constructor
         { 
              cout << "called B's conversion constructor" << endl; 
         } 
};

class A { 
      public: 
         operator B() const //conversion operator
         { 
              cout << "called A's conversion operator" << endl; 
              return B(); 
         } 
};

int main()
{
    A a;

    //Original code, This is ambiguous, 
    //because both operator and constructor have same cv qualification (use -pedantic flag)
    B b = a;

    //Why isn't this ambiguous, Why …

我有一个类,复制构造函数和构造函数采用std::reference_wrapper:

#include <functional>
#include <iostream>

class Class {
public:
    Class() {
        std::cout << "Class()" << std::endl;
    }
    Class(Class const &) {
        std::cout << "Class(Class const &)" << std::endl;
    }
    Class(std::reference_wrapper<Class>) {
        std::cout << "Class(std::reference_wrapper<Class>)" << std::endl;
    }
    Class(std::reference_wrapper<const Class>) {
        std::cout << "Class(std::reference_wrapper<const Class>)" << std::endl;
    }
};

int main() {
    Class a;
    Class b = a;
    Class c = std::ref(a);
    Class d = std::cref(a);
}

当正常编译时(g++ --std=c++17 test.cpp),它按照需要工作,按顺序调用四个构造函数:

$ ./a.exe
Class()
Class(Class const &)
Class(std::reference_wrapper<Class>) …

#include <iostream>
using namespace std;

struct Y;

struct X
{
    X(const Y&) { cout << "converting constructor" << endl; }
};

struct Y
{
    operator X() { cout << "conversion function" << endl; }
};

void f(X x) {}

int main()
{
    Y y;
    f(y);
}

在上面,转换函数由我的编译器(gcc 4.6.1)优先于转换构造函数,但是在标准中它声明:

用户定义的转换仅在明确无误的情况下应用

在这种情况下似乎存在歧义.任何人都可以解释这个矛盾吗？

我原本以为不能编译.几年前我也非常肯定Scott Meyers写了这个具体的例子,并说它不会编译.我错过了什么？

我有2个非常简单的类,ClassA和ClassB.我希望能够从ClassB转换为ClassA.使用Sun C++ 5.11,它可以很好地编译并按照我的预期运行,根据这个:转换构造函数与转换运算符:优先级.

当我尝试使用gcc版本4.8.2编译它时,它给出了一个关于对重载函数的模糊调用的错误.当铸造看起来是一个相当明确的行为时,为什么这会表现不同？

守则:

main.cc

#include <iostream>

class ClassB;

class ClassA
{
    public:
    ClassA( const int& num )
    : _number( num )
    { std::cout << "ClassA int constructor\n"; }

    private:
    int _number;
};

class ClassB
{
    public:
    ClassB( const int& num )
    : _number( num )
    { std::cout << "ClassB int constructor\n"; }

    operator ClassA() const throw()
    {
        std::cout << "ClassB operator ClassA()\n";
        return ClassA( _number );
    }
    operator int() const throw()
    {
        std::cout << "ClassB …

是否可以在 C++ 中覆盖（C 风格）强制转换？

假设我有代码

double x = 42;
int k = (int)x;

我可以让第二行中的演员执行我写的一些代码吗？就像是

// I don't know C++
// I have no idea if this has more syntax errors than words
operator (int)(double) {
    std::cout << "casting from double to int" << std::endl;
}

^{我问的原因是因为“有没有办法让 gcc 或 clang 对显式转换发出警告？” 和我的建议。}

该标准似乎提供了两个规则来区分涉及用户定义的转换运算符的隐式转换序列:

C++ 11

13.3.3最佳可行功能[over.match.best]

[...]一个可行的功能F1被定义为比另一个可行的功能F2更好的功能,如果[...]

• 上下文是用户定义转换的初始化(见8.5,13.3.1.5和13.3.1.6),从返回类型F1到目标类型的标准转换序列(即,被初始化的实体的类型)是比从返回类型F2到目标类型的标准转换序列更好的转换序列.

13.3.3.2对隐式转换序列进行排序[over.ics.rank]

3 - 相同形式的两个隐式转换序列是无法区分的转换序列,除非以下规则之一适用:[...]

• 用户定义的转换序列U1是比另一个用户定义的转换序列U2更好的转换序列,如果它们包含相同的用户定义的转换函数或构造函数或聚合初始化,并且U1的第二标准转换序列优于第二标准转换序列U2.

据我了解,13.3.3允许编译器区分不同的用户定义的转换运算符,而13.3.3.2允许编译器区分不同的函数(某些函数的重载f),每个函数都需要在参数中进行用户定义的转换(请参阅我的侧边栏给出以下代码(在GCC 4.3中),为什么转换为引用调用两次？).

是否有其他规则可以区分用户定义的转换序列？/sf/answers/96883111/上的答案表明,13.3.3.2:3可以根据隐式对象参数(转换运算符)的cv限定来区分用户定义的转换序列,或者构造函数或聚合初始化的单个非默认参数,但我不知道这是如何相关的,因为这需要比较各个用户定义的转换序列的第一个标准转换序列,标准没有似乎提到了.

假设S1优于S2,其中S1是U1的第一个标准转换序列,S2是U2的第一个标准转换序列,那么U1是否优于U2？换句话说,这段代码是否格式良好？

struct A {
    operator int();
    operator char() const;
} a;
void foo(double);
int main() {
    foo(a);
}

g ++(4.5.1),Clang(3.0)和Comeau(4.3.10.1)接受它,更喜欢非const限定A::operator int(),但我希望它被拒绝为含糊不清且因此格式错误.这是标准中的缺陷还是我对它的理解？

我刚看到一些我不太了解的东西.我认为这static_cast<TYPE>(variable)相当于(或更好/更安全)TYPE(variable).但是,以下代码不起作用

HMENU hMenu = CreateMenu();
HMENU hSubMenu = CreatePopupMenu();

// File
AppendMenu(hSubMenu, MF_STRING, WndClass_main::ID_FILE_EXIT, "&Quit");
AppendMenu(hMenu, MF_STRING | MF_POPUP, static_cast<intptr_t>(hSubMenu), "&File");

我的编译器说它无法转换HMENU为intptr_t.我有一个64位系统顺便说一句,这与间铸造interfers void*和int？但是,根据我的理解,类型intptr_t(在cstdint中定义)保证足够大void*.

有趣的是,以下(注意不同的演员)有效:

HMENU hMenu = CreateMenu();
HMENU hSubMenu = CreatePopupMenu();

// File
AppendMenu(hSubMenu, MF_STRING, WndClass_main::ID_FILE_EXIT, "&Quit");
AppendMenu(hMenu, MF_STRING | MF_POPUP, (intptr_t)(hSubMenu), "&File");

我错过了什么？

我处于这样一种情况,我必须生成将要从JNI使用的C++代码.我已经与java peer一起定义了传递数据的正确结构.然而,我被要求使用遗留的,hacky和超丑的结构而不是设计的干净结构.所以我有类似的东西:

struct NiceStructure{
    int a;
    int b;
    bool c;
};


struct LegacyStructure{
    string a;
    double b;
    bool c;
    int old_dont_use;
    string type;
    int I_dont_remember_what_this_is_but_dont_touch_it;
    bool clip;
};

将NiceStructure非常适合我要执行的操作和LegacyStructure可以被黑客攻击(如它历来)做我想做的事情.

问题是:我可以编写一个可以处理这两种结构的类型不可知函数吗？

一个示例函数是:

vector<NiceStructure> do_something(vector<NiceStructure> array_of_values){      
    vector<NiceStructure> res;
    for (int i=0; i< array_of_values.size(); i++){
        if (array_of_values[i].a + array_of_values[i].b > 10 && array_of_values[i].c)
            res.push_back(array_of_values[i])
    }
    return res;
}

我应该能够更改类型NiceStructure由LegacyStructure以某种方式和工作有其一.