C++基础语法简单介绍(二) -- C with classess

原创

用户10859876

修改于 2025-01-15 14:05:05

7400

代码可运行

运行总次数：0

代码可运行

1.构造函数, 析构函数

class Student {
    // 成员变量
    string name;
    int age;
    
    // 构造函数
    Student() {
        name = "未命名";
        age = 0;
    }
    
    // 析构函数
    ~Student() {
        cout << "对象被销毁" << endl;
    }
    
    // 成员函数
    void display() {
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }
};

构造函数 (Constructor)

主要作用：

在创建对象时自动调用

初始化对象的成员变量

为对象分配资源

特点：

函数名与类名相同

没有返回值类型

可以有多个（重载）

可以有参数

析构函数 (Destructor)

主要作用：

在对象被销毁时自动调用

释放对象占用的资源

清理工作（如关闭文件、释放内存等）

特点：

函数名是类名前加~

没有返回值

不能有参数

每个类只能有一个析构函数

2.类定义和类对象

// 类的定义
class Student {
    // 成员变量
    string name;
    int age;
    
    // 构造函数
    Student() {
        name = "未命名";
        age = 0;
    }
    
    // 析构函数
    ~Student() {
        cout << "对象被销毁" << endl;
    }
    
    // 成员函数
    void display() {
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }
};

// 主函数中使用Student类
int main() {
    // 创建对象
    Student student1;          // 使用默认构造函数创建对象
    Student student2;          // 创建另一个对象
    
    // 调用成员函数
    student1.display();        // 显示student1的信息
    student2.display();        // 显示student2的信息
    
    return 0;
}

对象的概念

对象是类的实例

每个对象都有自己的成员变量副本

可以创建同一个类的多个对象

创建对象的方式

直接声明：Student student1;

对象会自动调用构造函数进行初始化

访问对象的成员

使用点运算符（.）访问对象的成员

例如：student1.display();

3.类成员函数和类成员变量

class Student {
    // 成员变量（属性）
    string name;        // 普通成员变量
    int age;           // 普通成员变量
    static int totalStudents;  // 静态成员变量
    const int studentId;       // 常量成员变量
    
    // 成员函数（方法）
    // 构造函数
    Student(string n = "未命名", int a = 0) : studentId(totalStudents + 1) {
        name = n;
        age = a;
        totalStudents++;
    }
    
    // 普通成员函数
    void setName(string n) {
        name = n;
    }
    
    void setAge(int a) {
        age = a;
    }
    
    // 常量成员函数（不会修改类的成员变量）
    void display() const {
        cout << "学号：" << studentId << endl;
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }
    
    // 静态成员函数
    static int getTotalStudents() {
        return totalStudents;
    }
};

// 静态成员变量的初始化
int Student::totalStudents = 0;

成员变量的类型：

普通成员变量

如 name、age

每个对象都有自己的一份副本

可以随时修改

静态成员变量

如 totalStudents

所有对象共享一份

需要在类外初始化

常量成员变量

如 studentId

必须在构造函数的初始化列表中初始化

初始化后不能修改

成员函数的类型：

普通成员函数

如 setName()、setAge()

可以访问和修改类的所有成员变量

每个对象都可以调用

常量成员函数

如 display()

不能修改类的成员变量

函数声明后面加 const 关键字

静态成员函数

如 getTotalStudents()

只能访问静态成员变量

不需要创建对象就能调用

4.访问控制关键字public, private, protected

class Student {
private:    // 私有部分：只能在类内部访问
    // 成员变量（属性）通常设为私有
    string name;        
    int age;           
    static int totalStudents;  
    const int studentId;       

public:     // 公有部分：可以在类外部访问
    // 构造函数通常设为公有，这样才能创建对象
    Student(string n = "未命名", int a = 0) : studentId(totalStudents + 1) {
        name = n;
        age = a;
        totalStudents++;
    }
    
    // 对外的接口函数设为公有
    void setName(string n) {
        name = n;
    }
    
    void setAge(int a) {
        age = a;
    }
    
    void display() const {
        cout << "学号：" << studentId << endl;
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }
    
    // 静态成员函数也可以有访问控制
    static int getTotalStudents() {
        return totalStudents;
    }
};

// 静态成员变量的初始化
int Student::totalStudents = 0;

int main() {
    Student s1("张三", 18);
    
    // 正确：访问公有成员函数
    s1.setName("张三丰");
    s1.display();
    cout << "学生总数：" << Student::getTotalStudents() << endl;
    
    // 错误：不能直接访问私有成员
    // s1.name = "张三丰";    // 编译错误
    // s1.age = 20;          // 编译错误
    
    return 0;
}

访问控制说明：

private（私有）

默认情况下，class 的成员都是私有的

只能在类的内部访问

通常用于成员变量，保护数据不被外部直接访问

public（公有）

可以在类的外部访问

通常用于：

构造函数

接口函数（如 get/set 方法）

对外提供的服务函数

protected（保护）

这里没有使用，会在继承时讲解

允许子类访问父类的成员

5.集成和多重继承

面向对象三大特性

封装：隐藏实现细节，提供清晰的接口。

继承：实现代码复用和层次化设计。

多态：支持运行时动态绑定，提高代码的灵活性。

(简单讲解一下, 快速跳转到多态)

单继承

// 基类（父类）
class Person {
protected:  // protected允许子类访问
    string name;
    int age;
    
public:
    Person(string n = "", int a = 0) : name(n), age(a) {}
    
    virtual void display() const {  // 虚函数，支持多态
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }
};

// 派生类（子类）
class Student : public Person {  // public继承
private:
    int studentId;
    float score;
    
public:
    Student(string n, int a, int id, float s) 
        : Person(n, a), studentId(id), score(s) {}  // 调用父类构造函数
        
    // 重写父类的虚函数
    void display() const override {
        Person::display();  // 调用父类的方法
        cout << "学号：" << studentId << endl;
        cout << "成绩：" << score << endl;
    }
};

多重继承(可跳过)

// 另一个基类
class Employee {
protected:
    int employeeId;
    double salary;
    
public:
    Employee(int id = 0, double s = 0.0) 
        : employeeId(id), salary(s) {}
        
    virtual void showSalary() const {
        cout << "工号：" << employeeId << endl;
        cout << "薪资：" << salary << endl;
    }
};

// 多重继承
class PartTimeStudent : public Student, public Employee {
private:
    int workHours;
    
public:
    PartTimeStudent(string n, int a, int sid, float sc, 
                   int eid, double sal, int hours)
        : Student(n, a, sid, sc),          // 初始化第一个父类
          Employee(eid, sal),              // 初始化第二个父类
          workHours(hours) {}              // 初始化自己的成员
          
    void display() const override {
        Student::display();    // 调用Student的display
        Employee::showSalary();// 调用Employee的showSalary
        cout << "工作时长：" << workHours << "小时" << endl;
    }
};

继承的访问控制(可跳过)

class Base {
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

// public继承：保持原有的访问权限
class Derived1 : public Base {
    // pub 仍然是 public
    // prot 仍然是 protected
    // priv 不可访问
};

// protected继承：public和protected成员变为protected
class Derived2 : protected Base {
    // pub 变成 protected
    // prot 仍然是 protected
    // priv 不可访问
};

// private继承：所有成员变为private
class Derived3 : private Base {
    // pub 变成 private
    // prot 变成 private
    // priv 不可访问
};

6.重载和重写(可跳过)

7.虚函数(可跳过)

8.多态

#include <iostream>
using namespace std;

// 基类：动物
class Animal {
public:
    // 虚函数，将被子类重写
    virtual void makeSound() {
        cout << "动物发出声音" << endl;
    }
    
    // 虚析构函数（好习惯）
    virtual ~Animal() {
        cout << "动物被销毁" << endl;
    }
};

// 子类：狗
class Dog : public Animal {
public:
    // 重写基类的虚函数
    void makeSound() override {
        cout << "狗说：汪汪！" << endl;
    }
};

// 子类：猫
class Cat : public Animal {
public:
    // 重写基类的虚函数
    void makeSound() override {
        cout << "猫说：喵喵～" << endl;
    }
};

// 统一处理不同动物的函数
void letAnimalSpeak(Animal* animal) {
    animal->makeSound();  // 调用相应动物的声音
}

int main() {
    cout << "=== 创建动物 ===" << endl;
    Animal* dog = new Dog();  // 用基类指针指向狗
    Animal* cat = new Cat();  // 用基类指针指向猫
    
    cout << "\n=== 让动物们叫 ===" << endl;
    letAnimalSpeak(dog);  // 输出：狗说：汪汪！
    letAnimalSpeak(cat);  // 输出：猫说：喵喵～
    
    cout << "\n=== 释放内存 ===" << endl;
    delete dog;
    delete cat;
    
    return 0;
}

9.运算符重载(可跳过)

10.抽象类(可跳过)

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

c++

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

c++

作者已关闭评论

0 条评论

热度