有如下的类定义： class Sample { public: Sample( ); Sample(int x ); ...... }; 动态申请对象存储单元，调用无参构造函数的语句是（）。 A.Sample *a=new Sample; B.Sample *a=new Sample(2); C.Sample a=new Sample; D.Sample a=new Sample( );这道题选哪个选项 为甚恶魔

这道题的正确选项是：

A. Sample *a = Sample;

这是动态申请对象存储单元并调用无参构造函数的语句。使用关键字`new`动态分内存，并调用类的无参构函数来创建对象。然后将对象的赋给指针变量`a`。

选项的解释如下：

B Sample *a = new Sample2);
这是动申请对象存储单元并调带有一个整数参数的构造函数的语句。

C. Sample a = new Sample;
这不是动态申请对象存储单元的语句。同时，使用了错误的语法，应该是`Sample *a = new Sample;`才正确。

D. Sample a = new Sample( );
这也不是动态申请对象存储单元的语句。同时，使用了错误的语法，应该是`Sample *a = new Sample;`才正确。

相关问题

class Sample private: public: Sample(int i) ( n= i;} ___int add(Sample& s1, Sample& s2); int add(Sample& s1, Sample& s2) return s1.n + s2.n: int main@ f Sample s1(10), s2(20); cout <<___<< endl; return 0:横线处需要补充什么

需要补充 `add(s1, s2)`。完整的代码如下：

class Sample {
private:
    int n;
public:
    Sample(int i) { n = i; }
    int add(Sample& s1, Sample& s2);
};

int Sample::add(Sample& s1, Sample& s2) {
    return s1.n + s2.n;
}

int main() {
    Sample s1(10), s2(20);
    cout << s1.add(s1, s2) << endl;
    return 0;
}

class Sample { public: Sample(int a){X=a;} void Print()const{cout<<"Const:X="<<X<<endl;} void Print(){cout<<"X="<<X<<endl;} private: int X; }; int main() { const Sample s1(10); Sample s2(20); s1.Print(); s2.Print(); return 0; }

这段代码的输出结果是：

Const:X=10
X=20

下面是代码的详细解释：

1. 定义一个名为 Sample 的类，包含一个私有整型成员变量 X，一个带参数的构造函数和两个名字相同但参数不同的 Print 函数。

class Sample {
public:
    Sample(int a) { X = a; }
    void Print() const { cout << "Const:X=" << X << endl; }
    void Print() { cout << "X=" << X << endl; }
private:
    int X;
};

2. 在主函数中创建一个常量对象 s1 和一个非常量对象 s2，分别使用构造函数参数 10 和 20 进行初始化。

const Sample s1(10);
Sample s2(20);

3. 调用对象 s1 的 Print() 函数时，由于该函数被声明为 const，因此将调用 const 版本的 Print() 函数，输出常量对象 s1 的成员变量 X 的值。

s1.Print();

4. 调用对象 s2 的 Print() 函数时，由于该函数未被声明为 const，因此将调用非 const 版本的 Print() 函数，输出非常量对象 s2 的成员变量 X 的值。

s2.Print();

因此，程序将输出以下内容：

Const:X=10
X=20

需要注意的是，const 成员函数只能访问对象的 const 成员变量或 const 成员函数，而非 const 成员函数可以访问对象的任意成员变量或成员函数。此外，如果一个函数既有 const 版本又有非 const 版本，且被调用的对象为常量对象时，将优先调用 const 版本的函数。