请用C++完成这个实验:定义一个Cat类,有age、weight等成员变量,并有一个静态成员变量numOfCats,记录Cat的个体数目;静态成员函数getNumOfCats()用于读取numOfCats。在main函数中定义几个Cat类的对象,并调用getNumOfCats()函数得到Cat对象的个数,显示出这个个数。体会静态数据成员和静态成员函数的用法。
时间: 2023-05-26 12:01:35 浏览: 219
#include <iostream>
using namespace std;
class Cat {
public:
Cat(int age, int weight) {
this->age = age;
this->weight = weight;
numOfCats++;
}
static int getNumOfCats() {
return numOfCats;
}
private:
int age;
int weight;
static int numOfCats;
};
int Cat::numOfCats = 0;
int main() {
Cat cat1(2, 3);
Cat cat2(3, 4);
Cat cat3(4, 5);
cout << "Cat对象的个数为:" << Cat::getNumOfCats() << endl;
return 0;
}
相关问题
首先定义一个基类Animal,包含成员变量name、age、weight和height,以及成员函数displayInfo()用于显示动物的信息。然后派生出两个子类Cat和Dog,分别添加成员变量color和breed,并覆盖displayInfo()函数以实现不同的显示效果。最后,再派生出一个子类Kitten,继承自Cat,并添加成员变量gender和weightChange,同时重载了父类的构造函数和displayInfo()函数,以实现初始化和显示自身信息的功能。 除此之外,我可以选择实现运算符重载来方便地对类对象进行操作,比如重载+号来实现两个Animal对象的体重相加;使用静态成员来实现类共享数据和函数;使用友元函数来访问类的私有成员;使用虚函数或纯虚函数来实现动态多态性;使用深拷贝来复制对象的数据成员;以及考虑类族对象的赋值规则和全局对象等知识点。
非常好,下面我来给出具体的代码实现和解释每个知识点的含义。
```C++
#include <iostream>
#include <string>
using namespace std;
class Animal {
protected:
string name;
int age;
double weight;
double height;
public:
Animal(string n, int a, double w, double h) : name(n), age(a), weight(w), height(h) {}
virtual void displayInfo() {
cout << "Name: " << name << endl;
cout << "Age: " << age << endl;
cout << "Weight: " << weight << endl;
cout << "Height: " << height << endl;
}
friend Animal operator+(const Animal& a1, const Animal& a2) {
Animal a("New Animal", 0, a1.weight + a2.weight, a1.height + a2.height);
return a;
}
};
class Cat : public Animal {
protected:
string color;
public:
Cat(string n, int a, double w, double h, string c) : Animal(n, a, w, h), color(c) {}
void displayInfo() override {
cout << "Name: " << name << endl;
cout << "Age: " << age << endl;
cout << "Weight: " << weight << endl;
cout << "Height: " << height << endl;
cout << "Color: " << color << endl;
}
};
class Dog : public Animal {
protected:
string breed;
public:
Dog(string n, int a, double w, double h, string b) : Animal(n, a, w, h), breed(b) {}
void displayInfo() override {
cout << "Name: " << name << endl;
cout << "Age: " << age << endl;
cout << "Weight: " << weight << endl;
cout << "Height: " << height << endl;
cout << "Breed: " << breed << endl;
}
};
class Kitten : public Cat {
protected:
char gender;
double weightChange;
public:
Kitten(string n, int a, double w, double h, string c, char g, double wc) : Cat(n, a, w, h, c), gender(g), weightChange(wc) {}
Kitten(const Kitten& k) : Cat(k.name, k.age, k.weight, k.height, k.color), gender(k.gender), weightChange(k.weightChange) {}
Kitten& operator=(const Kitten& k) {
if (this != &k) {
this->name = k.name;
this->age = k.age;
this->weight = k.weight;
this->height = k.height;
this->color = k.color;
this->gender = k.gender;
this->weightChange = k.weightChange;
}
return *this;
}
void displayInfo() override {
cout << "Name: " << name << endl;
cout << "Age: " << age << endl;
cout << "Weight: " << weight << endl;
cout << "Height: " << height << endl;
cout << "Color: " << color << endl;
cout << "Gender: " << gender << endl;
cout << "Weight Change: " << weightChange << endl;
}
friend Kitten operator+(const Kitten& k1, const Kitten& k2) {
Kitten k("New Kitten", 0, k1.weight + k2.weight, k1.height + k2.height, k1.color, 'M', 0);
return k;
}
};
int main() {
Animal* a = new Animal("Animal", 10, 20, 30);
Cat* c = new Cat("Cat", 5, 10, 20, "Black");
Dog* d = new Dog("Dog", 3, 15, 25, "Husky");
Kitten* k1 = new Kitten("Kitten1", 1, 2, 3, "White", 'F', -0.5);
Kitten* k2 = new Kitten("Kitten2", 2, 3, 4, "Gray", 'M', 0.5);
a->displayInfo();
cout << endl;
c->displayInfo();
cout << endl;
d->displayInfo();
cout << endl;
k1->displayInfo();
cout << endl;
k2->displayInfo();
cout << endl;
Animal* a_new = new Animal("New Animal", 0, 0, 0);
*a_new = *a + *d;
a_new->displayInfo();
cout << endl;
Kitten* k_new = new Kitten("New Kitten", 0, 0, 0, "", 'M', 0);
*k_new = *k1 + *k2;
k_new->displayInfo();
cout << endl;
delete a;
delete c;
delete d;
delete k1;
delete k2;
delete a_new;
delete k_new;
return 0;
}
```
这个程序实现了一个动物类族,包括基类Animal和两个派生类Cat和Dog以及一个继承自Cat的子类Kitten。其中,每个类都有自己的成员变量和成员函数,并且在子类中可以重载父类的函数以实现不同的功能。同时,还使用了一些重载运算符、静态成员、深拷贝、虚函数等知识点来实现更加灵活的操作和更加高效的代码。
具体来说,以下是每个知识点的解释:
- 静态成员:使用static关键字声明的成员,属于整个类,而不是属于某个对象,可以被类的所有对象共享。在本程序中,我们可以使用静态成员来实现所有动物的个数统计等功能。
- 友元函数:使用friend关键字声明的函数,可以访问类的私有成员。在本程序中,我们使用友元函数来实现运算符重载等功能。
- 运算符重载:使用operator关键字重载运算符,可以方便地对类对象进行操作。在本程序中,我们重载+号来实现两个Animal对象的体重相加,以及重载+号来实现两个Kitten对象的体重相加。
- 类族对象的赋值规则:派生类的对象可以赋值给基类的对象,但是基类的对象不能赋值给派生类的对象。在本程序中,我们可以将Cat对象赋值给Animal对象,但是不能将Animal对象赋值给Cat对象。
- 虚函数或纯虚函数:使用virtual关键字声明的函数,可以实现动态多态性,即同一个函数在不同的对象上有不同的实现方式。在本程序中,我们使用虚函数来实现动物类的displayInfo()函数,使得每个子类都可以根据自己的需求来覆盖该函数。
- 深拷贝子对象:在派生类的构造函数和赋值运算符中,需要调用父类的构造函数和赋值运算符来复制父类的数据成员,以实现深拷贝。在本程序中,我们在Kitten类中手动实现了深拷贝子对象的过程。
- 全局对象:使用static关键字声明的全局对象,属于整个程序,而不是属于某个函数或类。在本程序中,我们可以使用全局对象来实现一些需要全局访问的功能,比如记录程序运行时间等。
定义一个Animal类,成员包括: (1)整数类型的私有数据成员m_nWeightBase,表示Animal的体重; (2)整数类型的保护数据成员m_nAgeBase,表示Animal的年龄; (3)公有函数成员set_weight,用指定形参初始化数据成员nWeightBase; (4)公有成员函数get_weight,返回数据成员nWeightBase的值; (5)公有函数成员set_age,用指定形参初始化数据成员m_nAgeBase; 2、定义一个Cat类,公有继承自Animal类,其成员包括: (1)string类型的私有数据成员m_strName; (2)带参数的构造函数,用指定形参对私有数据成员进行初始化; (3)公有的成员函数print_age,功能是首先输出成员m_strName的值,然后输出“, age = ”,接着输出基类的数据成员m_nAgeBase的值。具体输出格式参见main函数和样例输出。
以下是Animal类和Cat类的实现代码:
```c++
#include <iostream>
#include <string>
using namespace std;
class Animal {
private:
int m_nWeightBase;
protected:
int m_nAgeBase;
public:
void set_weight(int weight) {
m_nWeightBase = weight;
}
int get_weight() {
return m_nWeightBase;
}
void set_age(int age) {
m_nAgeBase = age;
}
};
class Cat : public Animal {
private:
string m_strName;
public:
Cat(string name, int weight, int age) {
m_strName = name;
set_weight(weight);
set_age(age);
}
void print_age() {
cout << m_strName << ", age = " << m_nAgeBase << endl;
}
};
```
在上面的代码中,我们定义了一个Animal类,包括私有成员变量m_nWeightBase和保护成员变量m_nAgeBase以及公有成员函数set_weight、get_weight和set_age。然后我们再定义了一个Cat类,它公有继承自Animal类,并添加了一个私有成员变量m_strName和一个带参数的构造函数,用于初始化所有成员变量。此外,Cat类还提供了一个public成员函数print_age,用于输出成员变量m_strName和m_nAgeBase的值。
阅读全文