c++类定义

一、类的基本定义和使用

类是c++中一种自定义的数据类型，可以用来封装数据和方法。类由成员变量和成员函数组成。以下是一个简单的类定义：

class Person {
public:
    string name;
    int age;
    void printInfo() {
        cout << "name:" << name << ", age:" << age << endl;
    }
};

在上面的代码中，我们定义了一个Person类，它有两个成员变量（name和age）和一个成员函数(printInfo)。成员变量和成员函数可以使用public、protected、private关键字进行访问控制。

使用该类也很简单：

//创建对象
Person p;
//给成员变量赋值
p.name = "Bob";
p.age = 20;
//调用成员函数
p.printInfo();

输出结果为：name:Bob, age:20。

二、构造函数和析构函数

构造函数和析构函数是类中非常重要的概念。构造函数用于对象的初始化，而析构函数用于对象的销毁。

以下是一个简单的构造函数和析构函数的定义：

class Person {
public:
    string name;
    int age;
    //构造函数
    Person(string n, int a) {
        name = n;
        age = a;
        cout << "Constructor is called!" << endl;
    }
    //析构函数
    ~Person() {
        cout << "Destructor is called!" << endl;
    }
    void printInfo() {
        cout << "name:" << name << ", age:" << age << endl;
    }
};

在上面的代码中，我们定义了一个带参数的构造函数和一个析构函数。我们创建对象时，将自动调用构造函数进行初始化，销毁对象时将自动调用析构函数。

使用该类也很简单：

//创建对象
Person p("Bob", 20);
//调用成员函数
p.printInfo();

输出结果为：Constructor is called! name:Bob, age:20 Destructor is called!

三、访问控制

c++中有三种访问控制权限：public、protected和private。public表示该成员可以被类的外部访问，protected表示该成员可以被类的子类访问，private表示该成员只能在类的内部访问。

以下是一个具体的例子：

class Person {
public:
    string name;
    //公有成员函数
    void setName(string n) {
        //可以访问私有成员变量
        this->name = n;
        //可以访问私有成员函数
        this->setAge(20);
    }
protected:
    int age;
    //受保护的成员函数
    void setAge(int a) {
        //只能在类内部访问私有成员变量
        this->age = a;
    }
private:
    string gender;
};

在上面的代码中，我们定义了一个Person类，它有一个public成员函数(setName)、一个protected成员变量(age)和一个private成员变量(gender)。在public成员函数中，我们可以访问私有成员变量和私有成员函数，而在类的外部同样可以访问该函数。

四、继承和多态

继承是面向对象程序设计中的一个重要概念。它可以帮助我们实现代码的复用。子类可以继承父类的成员变量和成员函数，并且还可以扩展自己的新的成员变量和成员函数。

以下是一个简单的继承的例子：

class Student : public Person {
public:
    int studentId;
    //子类的构造函数
    Student(string n, int a, int id) : Person(n, a) {
        studentId = id;
    }
    //子类的成员函数
    void printStudentInfo() {
        cout << "name:" << name << ", age:" << age << ", studentId:" << studentId << endl;
    }
};

在上面的代码中，我们定义了一个Student类，它继承了Person类的成员变量和成员函数，同时还有自己的成员变量(studentId)和成员函数(printStudentInfo)。

使用该类也很简单：

//创建对象
Student s("Amy", 18, 20210001);
//调用成员函数
s.printStudentInfo();

输出结果为：name:Amy, age:18, studentId:20210001。

多态是面向对象程序设计中的另一个重要概念。它允许我们按照统一的接口而非具体的实现来调用对象。c++中实现多态有两种方式：虚函数和纯虚函数。

以下是一个简单的虚函数的例子：

class Shape {
public:
    //虚函数
    virtual double getArea() {
        return 0;
    }
};
class Triangle : public Shape {
public:
    int base;
    int height;
    Triangle(int b, int h) {
        base = b;
        height = h; 
    }
    //重写虚函数
    double getArea() {
        return 0.5*base*height;
    }
};
class Square : public Shape {
public:
    int side;
    Square(int s) {
        side = s;
    }
    //重写虚函数
    double getArea() {
        return side*side;
    }
};

在上面的代码中，我们定义了一个抽象类Shape，它有一个虚函数(getArea)。我们继承Shape，实现了具体的图形类Triangle和Square。这些具体的类重写了抽象类Shape中的虚函数。

使用该类也很简单：

//创建对象
Shape *s1 = new Triangle(10, 5);
Shape *s2 = new Square(8);
//调用虚函数
cout << "Triangle area is: " << s1->getArea() << endl;
cout << "Square area is: " << s2->getArea() << endl;

输出结果为：Triangle area is: 25，Square area is: 64。

五、模板类

c++中的模板类可以帮助我们快速实现通用类。模板类是一种特殊的类，它可以使用一个或多个类型作为参数。

以下是一个简单的模板类的定义：

template 
class Stack {
private:
    T *data;
    int topIndex;
    int size;
public:
    //构造函数
    Stack(int s) {
        data = new T[s];
        topIndex = -1;
        size = s;
    }
    //析构函数
    ~Stack() {
        delete[] data;
    }
    //压栈函数
    void push(T d) {
        if (topIndex < size-1) {
            data[++topIndex] = d;
        }
    }
    //弹栈函数
    T pop() {
        if (topIndex >= 0) {
            return data[topIndex--];
        }
        return NULL;
    }
};

  

在上面的代码中，我们定义了一个模板类Stack，它有一个类型参数T。该类有两个成员变量(data和topIndex)和两个成员函数(push和pop)。成员函数可以使用T类型作为参数和返回值。

使用该类也很简单：

//创建Stack对象
Stack s(100);
//压栈
s.push(10);
s.push(20);
//弹栈
cout << s.pop() << endl;
cout << s.pop() << endl;

  

输出结果为：20，10。