(1)写一个含有数据成员a 的类C并用两种方法初始化 a。 (2)写一个含有类型为C的数据成员c的类B并用两种方法 初始化c。 (3)在主函数中 ①创建B类的堆对象并用118 初始化之。 ②创建B类的堆对象数组，元素个数由键盘输入决定。 ③释放上面创建的堆对象和堆对象数组。

(1)：

class C {
public:
    int a;
    C() { a = 0; } // 方法1：默认构造函数初始化为0
    C(int n) { a = n; } // 方法2：带参数的构造函数初始化为n
};

(2)：

class B {
public:
    C c;
    B() {} // 方法1：默认构造函数不初始化c（由C的默认构造函数初始化为0）
    B(int n) : c(n) {} // 方法2：带参数的构造函数初始化c为n
};

(3):

int main() {
    // 创建B类的堆对象并用118初始化之
    B* b1 = new B(118);

    // 创建B类的堆对象数组，元素个数由键盘输入决定
    int n;
    cin >> n;
    B* bArr = new B[n];
    for (int i = 0; i < n; i++) {
        bArr[i].c.a = i; // 初始化c的a成员为i
    }

    // 释放堆对象和堆对象数组
    delete b1;
    delete[] bArr;

    return 0;
}

相关问题

(1)写一个含有int 型数据成员 a 的类C并用两种方法初始化 a 的值。 (2)在主函数中定义类C的一个对象并用 整数37给它赋值。

(1) 类C的定义如下：

class C {
public:
    int a; // int型数据成员a

    // 方法一：在构造函数中初始化a
    C(int value) {
        a = value;
    }

    // 方法二：使用初始化列表初始化a
    C(): a(0) {
        // 构造函数体
    }
};

(2) 在主函数中定义类C的一个对象并用整数37给它赋值的代码如下：

int main() {
    // 定义类C的一个对象并用整数37给它赋值
    C c;
    c.a = 37;

    return 0;
}

(1)写一个含有数据成员a的类C并用两种方 法初始化a的值。 (2)写一个以C类对象指针为参数的函数，该 函数可使参数指向的对象的数据成员a的增 （3）写一个以C类对象引用为参数的函数，该 函数可使参数指向的对象的数据成员a的减一

(1) 假设数据成员a是整型变量，可以定义一个类C如下：

class C {
private:
    int a;
public:
    C() { a = 0; } // 默认构造函数，将a初始化为0
    C(int value) { a = value; } // 带参构造函数，将a初始化为value
    int getA() { return a; } // 获取a的值的方法
};

(2) 可以定义一个函数，接受一个C类对象指针作为参数，并将其data成员a增加1：

void increaseA(C* obj) {
    obj->a++;
}

(3) 可以定义一个函数，接受一个C类对象引用作为参数，并将其data成员a减1：

void decreaseA(C& obj) {
    obj.a--;
}