标签: initialization

我在一个旧的桌面应用程序中有一些代码，这是我从一位离开公司的同事那里继承的。这是我实际代码的一个简短的类似示例：

#include <iostream>
int getType(int type)
{
    return type;
}

int main()
{
    int variable1 = 30;
    int variable2 = 40;
    int result = (getType(30) == (variable1 || variable2) ? 1 : 2);
    std::cout << result << std::endl;
}

对于结果，我总是收到 2，而不是我预期的 1。如果我尝试：

int result = (getType(30) == (variable1) ? 1 : 2)

结果是真的。

我不明白为什么这部分：

int result = (getType(30) == (variable1 || variable2) ? 1 : 2)

不是真的……

为什么我不能用字符串初始化本地数组

我是Obejtive C的新手,所以当时我正在查看很多示例代码,我注意到人们初始化他们的NSMutableArray的方式不同.

NSMutableArray *items = [NSMutableArray array];

要么

NSMutableArray *items = [[NSMutableArray alloc] init];

在这两行中,您最终得到一个NSMutableArray对象.
它们之间有什么区别或它们完全相同？

void first(){
    int x;
    int *p;
    p= &x;
    scanf("%d",p);
    printf("The value in x or *p is: %d\n",x);
}


void second(){
    int x;
    int *ptr;
    scanf("%d",&x);
    printf("The value in *ptr is: %d\n",*ptr);
}


int main(){
    first();
    second();
}

在上面的代码中,second()函数是miss行为.我为x赋值的变量*ptr以及x 赋予了什么值.为什么？

我的意思是问它是否遵循一些特定的算法,实际上不是垃圾.

换句话说,"垃圾"值究竟是如何存在的？考虑不调用UB,如果读取垃圾值,该值的来源是什么？

我有一个隐藏默认构造函数的类,强制使用带参数的构造函数.另一个类使用该类的2个实例:

typedef struct { ... } BAZ;

class Foo {
  private:
    Foo(void) {}

  public:
    Foo(BAZ a) { ... }
};

class Bar {
  private:
    Foo foo1;
    Foo foo2;

    Bar(void) {}

  public:
    Bar(BAZ a, BAZ b) : foo1(a), foo2(b) { ... }
};

最明显的是变量foo1和foo2的声明将调用默认的Foo构造函数,但由于它是私有的,它不能并且会给编译器错误.

有没有办法阻止它尝试默认的Foo构造函数,只是等待Bar构造函数初始化它们？

我想避免使用new关键字(这将解决整个问题).

编辑:
似乎人们很难理解问题和困境.我会试着解释一下:

我想强制使用Foo(BAZ)构造函数,这意味着任何使用Foo(void)构造函数的尝试都会产生错误.

要隐藏默认构造函数,它将被声明为私有成员.如果有人试图使用默认构造函数Foo(),它将给出故意错误.

要不声明默认构造函数,只声明Foo(BAZ)不会阻止编译器创建公共默认构造函数.如果我将其声明为Foo(),则不会出错.到目前为止它的工作正常并且符合预期.

第二类Bar有两个Foo实例,但是当实例化Bar时,这些Foo成员将使用默认(隐藏)构造函数调用并生成错误.然后在Bar构造函数中,这两个实例将使用正确的公共构造函数Bar(BAZ a,BAZ b)初始化:foo1(a),foo2(b).这就是我要的.

有没有办法防止它在初始化Bar时调用Foo默认构造函数,所以Bar构造函数可以使用正确的Foo构造函数？

该新解决方案的工作,因为默认的构造函数永远不会被调用:

BAZ a = {...}
Foo *foo1 = new Foo(a);

我希望这更清楚.

EDIT2:已解决 错误不在隐藏的Foo构造函数中,它是隐藏的Bar构造函数,试图使用隐藏的默认Foo构造函数.

Bar(void) : Foo(BAZ{}), Foo(BAZ{}) {}

解决了它.

编辑3:
真正的问题似乎是在开发工具中.重新启动并手动清除缓存后,它就像C++ 14标准一样工作.

假设我们在C中具有以下声明：

double d[25], * p;
int * t;
char * c;

我们如何解释以下printf（）结果？

printf("d : %x\t",d);
printf("p : %x\t",p);
printf("t : %x\t",t);
printf("c : %x\t",c);

哪个打印ligne：

d : 62fd30    p : 1    t : 0    c : 39    

我们可以很清楚地看到d的内存地址，但p，t和c看起来都不像地址。我曾经认为，未初始化的指针在声明后采用Null值。我错了吗？我们如何解释这些结果？

在下面的代码中，变量被多次初始化。

为什么此代码不引发错误？

int main() 
{ 
  int x;
  x=5;
  x=10;
  printf("\nx=%d",x) ;
}

节目输出

x = 10

这是我的代码:

int main()
{
    int *p;
    void *x;
    printf("%p\n", p);
    printf("%p\n", x);
    return 0;
}

将打印:

koraytugay $ ./a.out
0x7fff53b35ad0
0x0
koraytugay $ ./a.out
0x7fff5803fad0
0x0
koraytugay $ ./a.out
0x7fff512c9ad0
0x0
koraytugay $ ./a.out
0x7fff55213ad0
0x0
koraytugay $ ./a.out
0x7fff52dbdad0
0x0

这种行为在语言中有什么解释吗？

我正在尝试这个构造函数代码,并对它的工作方式感到困惑.

#include<iostream>
using namespace std;
class XYZ{
    int a,b;
    public:
        XYZ(int i, int j):a(i), b(a*j){}
        void show(){
            cout<<a<<"\t"<<b<<"\n";
        }
};
int main(){
    XYZ X(2,3);
    X.show();
    return 0;
}

它给出了预期的结果,但是,

#include<iostream>
using namespace std;
class XYZ{
    int b,a;
    public:
        XYZ(int i, int j):a(i), b(a*j){}
        void show(){
            cout<<a<<"\t"<<b<<"\n";
        }
};
int main(){
    XYZ X(2,3);
    X.show();
    return 0;
}

出乎意料的结果.

唯一的区别是int a,b和int b,a

以及如何XYZ(int i, int j):a(i), b(a*j){}正常工作？