C++类设计总结

最新推荐文章于 2024-09-11 19:54:50 发布
最新推荐文章于 2024-09-11 19:54:50 发布
阅读量121 收藏
点赞数
分类专栏： C++入门学习 文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54706831/article/details/128986330
版权
本文详细介绍了C++中的类设计，包括基类和派生类的构造函数、析构函数、赋值运算符的使用。特别强调了深拷贝的重要性，以及如何处理动态内存分配。此外，还讨论了友元函数、虚函数以及对象的初始化和赋值在继承层次中的行为。
摘要由CSDN通过智能技术生成

类设计总结

实例一

本实例设计了三个类。第一个是基类Person类，具有姓名(m_name)和年龄(m_age)属性。第二个学生类Student公有继承Person类，拥有性别(m_sex)属性。第三个老师类Teacher公有继承Person类，拥有学科(m_subject)属性。

Person.h

#ifndef DMA_H_
#define DMA_H_
#include <iostream>
// 基类
class Person
{
    private:
        char *m_name;   // 姓名
        int m_age;      // 年龄
    public:
        Person(const char *name = "", int age = 0); // 构造函数
        Person(const Person &p);    // 复制构造函数
        virtual ~Person();  // 虚析构函数
        Person& operator=(const Person &p); // 赋值运算符
        friend std::ostream& operator<<(std::ostream &os, const Person& p);     // 友元函数
};

// 派生类
class Student : public Person    // 公有继承
{
    private:
        enum {SEX_LEN = 10};    // 枚举
        char m_sex[SEX_LEN];    // 性别
    public:
        Student(const char *name = "", int age = 0, const char *sex = "female");    // 构造函数
        Student(const Person &p, const char *sex = "female");   // 构造函数
        friend std::ostream& operator<<(std::ostream& os, const Student &stu);  // 友元函数
};


// 派生类
class Teacher : public Person   // 公有继承
{
    private:
        char *m_subject;    // 科目
    public:
        Teacher(const char *name = "", int age = 0, const char *subject = "Chinese");   // 构造函数
        Teacher(const Person& p, const char *subject = "Chinese");      // 构造函数
        Teacher(const Teacher &tea);    // 复制构造函数
        Teacher& operator=(const Teacher &tea); // 赋值运算符
        virtual ~Teacher(); // 析构函数
        friend std::ostream& operator<<(std::ostream& os, const Teacher& tea);  // 友元函数

};
#endif

Person.cpp

#include "Person.h"
#include <cstring>

Person::Person(const char *name, int age)
{
    m_name = new char[strlen(name) + 1];
    strcpy(m_name, name);
    m_age = age;    
}

Person::Person(const Person& p)
{
    m_name = new char[strlen(p.m_name) + 1];
    strcpy(m_name, p.m_name);
    m_age = p.m_age;
}
Person::~Person()
{
    delete [] m_name;
    m_name = nullptr;
}

Person& Person::operator=(const Person& p)
{
    if(this == &p)
    {
        return *this;
    }
    delete [] m_name;
    m_name = new char[strlen(p.m_name) + 1];
    strcpy(m_name, p.m_name);
    m_age = p.m_age;
    return *this;
}

std::ostream& operator<<(std::ostream &os, const Person& p)
{
    os << "name: " << p.m_name << std::endl;
    os << "age: " << p.m_age << std::endl;
    return os;
}

Student::Student(const char *name, int age, const char *sex)
    : Person(name, age)     // 初始化成员列表
{
    strncpy(m_sex, sex, SEX_LEN - 1);
    m_sex[SEX_LEN - 1] = '\0';
}
Student::Student(const Person& p, const char *sex)
    : Person(p)
{
    strncpy(m_sex, sex, SEX_LEN - 1);
    m_sex[SEX_LEN - 1] = '\0';
}

std::ostream& operator<<(std::ostream& os, const Student &stu)
{
    os << (const Person &)stu;  // 强转成基类，输出基类部分的内容
    os << "Sex: " << stu.m_sex << std::endl;
    return os;
}


Teacher::Teacher(const char *name, int age, const char *subject)
    : Person(name, age)
{
    m_subject = new char[strlen(subject) + 1];
    strcpy(m_subject, subject);
}


Teacher::Teacher(const Person& p, const char *subject)
    : Person(p)
{
    m_subject = new char[strlen(subject) + 1];
    strcpy(m_subject, subject);
}

Teacher::Teacher(const Teacher &tea)
    : Person(tea)   // 使用基类的复制构造函数
{
    m_subject = new char[strlen(tea.m_subject) + 1];
    strcpy(m_subject, tea.m_subject);
}

Teacher& Teacher::operator=(const Teacher &tea)
{
    if(this == &tea)
    {
        return *this;
    }
    Person::operator=(tea);  // 调用基类的赋值运算符，给基类部分的成员赋值
    delete [] m_subject;
    m_subject = new char[strlen(tea.m_subject) + 1];
    strcpy(m_subject, tea.m_subject);
    return *this;
}

Teacher::~Teacher()
{
    delete [] m_subject;
    m_subject = nullptr;
}

std::ostream& operator<<(std::ostream& os, const Teacher& tea)
{
    os << (const Person&)tea;   // 强转成基类，输出基类部分的内容
    os << "Subject: " << tea.m_subject << std::endl;
    return os;
}

main.cpp

#include "Person.h"

int main()
{
    using std::cout;
    using std::endl;

    Person p1("zhangsan", 18);
    Person p2(p1);
    Person p3;
    p3 = p1;
    cout << "p1: \n" << p1 << endl;
    cout << "p2: \n" << p2 << endl;
    cout << "p3: \n" << p3 << endl;

    Student stu1("lisi", 19, "man");
    Student stu2(p1);
    Student stu3(stu2);
    Student stu4;
    stu4 = stu1;
    cout << "stu1: " << endl;
    cout << stu1 << endl;
    cout << "stu2: " << endl;
    cout << stu2 << endl;
    cout << "stu3: " << endl;
    cout << stu3 << endl;
    cout << "stu4: " << endl;
    cout << stu4 << endl;

    Teacher t1("wangwu", 17, "English");
    Teacher t2(p2, "Math");
    Teacher t3(t1);
    Teacher t4;
    t4 = t1;
    cout << "t1: " << endl;
    cout << t1 << endl;
    cout << "t2: " << endl;
    cout << t2 << endl;
    cout << "t3: " << endl;
    cout << t3 << endl;
    cout << "t4: " << endl;
    cout << t4 << endl;
    return 0;
}

实例说明

  1. Person类需要对m_name成员进行动态内存分配，所以需要自定义析构函数来释放动态内存分配的内存，同时需要定义显示复制构造函数和赋值运算符来进行深拷贝。
  2. 派生类Student没有使用动态内存分配，所以没有定义显示复制构造函数和赋值运算符。对于继承自基类的成员，Student的默认拷贝构造函数使用Person类的显示拷贝构造函数来拷贝Student对象的Person部分。对于赋值运算符来说也是如此，类的默认赋值运算符将自动使用基类的赋值运算符来对基类成员进行赋值。
  3. Teacher类需要对m_subject成员进行动态内存分配，所以需要自定义析构函数来释放动态内存分配的内存，同时需要定义显示复制构造函数和赋值运算符来进行深拷贝。
  4. 对于Teacher类的赋值运算符，需要显示调用基类的赋值运算符来对基类部分的成员进行赋值，通过作用域解析运算符::来调用基类的赋值运算符。
// 派生类的复制构造函数
Teacher::Teacher(const Teacher &tea)
    : Person(tea)   // 调用基类的复制构造函数
{
    m_subject = new char[strlen(tea.m_subject) + 1];
    strcpy(m_subject, tea.m_subject);
}

// 派生类的赋值运算符
Teacher& Teacher::operator=(const Teacher &tea)
{
    if(this == &tea)
    {
        return *this;
    }
    Person::operator=(tea);  // 调用基类的赋值运算符，给基类部分的成员赋值
    delete [] m_subject;
    m_subject = new char[strlen(tea.m_subject) + 1];
    strcpy(m_subject, tea.m_subject);
    return *this;
}
  1. 对于派生类的友元operator<<()，该函数只能访问本类成员，如果需要使用基类的友元来访问基类的成员，可以通过强制类型转换，将派生类转换成基类，以便能够访问派生类中的基类部分。
std::ostream& operator<<(std::ostream& os, const Teacher& tea)
{
    os << (const Person&)tea;   // 强转成基类，输出基类部分的内容
    os << "Subject: " << tea.m_subject << std::endl;
    return os;
}

类设计总结

编译器生成的成员函数

  1. 默认构造函数

    • 默认构造函数要么没有参数，要么所有的参数都有默认值。如果没有定义任何构造函数，编译器将定义默认构造函数，该默认构造函数将会自动调用基类的默认构造函数。

    • 如果派生类构造函数的成员初始化列表中没有显示调用基类构造函数，则编译器将使用基类的默认构造函数来构造派生类对象的基类部分。如果基类没有默认构造函数，将导致编译错误。

    • 如果定义了某种构造函数，编译器将不会定义默认构造函数，这种情况下，需要自己提供默认构造函数。

    • 所以最好提供一个显示默认构造函数，将所有的类数据成员都初始化为合理的值。

  2. 复制构造函数

复制构造函数接受其所属类的对象作为参数。例如Student类的复制构造函数原型如下:

Student(const Student &)

在以下情况下，将使用复制构造函数

  • 将新对象初始化为一个同类对象；
  • 按值将对象传递给函数；
  • 函数按值返回对象；
  • 编译器生成临时对象。

如果程序没有使用（显示或隐式）复制构造函数，编译器将提供原型，但不提供函数定义；否则， 程序将定义一个执行成员初始化的复制构造函数。

注意：如果使用new初始化成员指针则需要深拷贝，这时需要自己定义一个复制构造函数。

  1. 赋值运算符

赋值运算符用于处理同类对象之间的赋值，区别于初始化。如果语句创建新的对象，则是初始化；如果语句修改已有对象的值，则是赋值。

Student stu1;
Student stu2 = stu2;    // 初始化，调用复制构造函数
Student stu3;
stu3 = stu1;    // 赋值，调用赋值运算符

赋值运算符原型如下：

Student & operator=(const Student &);

注意：如果使用new初始化成员指针则需要深拷贝，这时需要自己定义赋值运算符。

其他类方法

  1. 构造函数

构造函数用于创建新的对象。

  1. 析构函数

析构函数用于做清理工作。一定要显示定义析构函数来释放类构造函数使用new分配的所有内存，并完成类对象所需的任何特殊的清理工作。对于基类，即使它不需要析构函数，也应提供一个虚析构函数。

  1. 转换

使用一个参数就可以调用的构造函数定义了从参数类型到类类型的转换。例如:

Student(const char *);      // const char *转换为Student类
Student(const Person &, int age = 1);   // 从Person类转换为Student类

将可转换的类型传递给以类为参数的函数时，将调用转换构造函数，例如:

Student stu1 = "zhangsan";  // 直接使用Student(const char *)构造出了Student对象

上述代码中进行了隐式转换，const char* 类型直接转换为了Student类型

禁止隐式转换使用explicit关键字，但仍可以进行显示转换

class Student
{
    public:
        explicit Student(const char *);
};

Student stu1 = "zhangsan";  // 报错，禁止隐式转换
Student stu1 = Student("zhangsan");     // 允许，允许显示转换
  1. 按值传递对象与传递引用

通常，编写使用对象作为参数的函数时，应按引用而不是按值来传递对象。

原因一：为了提高效率。按值传递对象涉及到生成临时拷贝，即调用复制构造函数，然后调用析构函数。调用这些函数需要时间，复制大型对象比传递引用花费的时间要多得多。

原因二：在继承使用虚函数时，被定义为接受基类引用参数的函数可以接受派生类。

  1. 返回对象和返回引用
Student get_stu(const Student &);       // 返回对象
Student & get_stu(const Student &);     // 返回引用
  • 返回对象是返回生成对象的临时副本。
  • 返回引用可以节省时间和空间，因为返回对象需要调用复制构造函数生成副本和析构函数删除副本。

如果函数返回在函数中创建的临时对象，则不要使用引用

Student Student::Sum(const Student &stu) const
{
    return Student(m_scores + stu.m_scores);    // 只能返回对象
}

如果函数返回的是通过引用或指针传递给他的对象，则应按引用返回对象。

const Student& Greater(const Student &stu1) const   // 按引用返回
{
    if(m_scores > stu1.m_scores)
    {
        return *this;
    }
    else
    {
        return stu1;
    }
}
  1. 使用const

const可以确保调用函数时不修改传递的参数。

Student::Student(const char *name) {...}    // 不能修改name

成员函数使用const可以确保函数不修改调用它的对象。

void Student::Show() const {...}    // 不能修改对象的参数

这里的const表示const Student *this，this指向调用的对象。

什么不能被继承

  1. 构造函数不能被继承。
    • 因为创建派生类对象时，必须调用派生类的构造函数；
    • 继承意味着派生类对象可以使用基类的方法，然而，构造函数在完成其工作之前，对象并不存在，也就无法调用使用基类方法。
  2. 析构函数不能被继承。因为，在释放对象时，程序将首先调用派生类的析构函数，然后调用基类的析构函数。因此基类的析构函数应该被声明为虚的。
  3. 赋值运算符不能被继承。因为，派生类继承的方法的特征标与基类完全相同，但赋值运算符的特征标随类而异，因为它包含一个类型为其所属类的形参。
  4. 友元函数不能被继承。因为友元函数并非类成员函数，所以不能被继承。

基类和派生类相互赋值的说明

  1. 将派生类赋给基类对象
Person p1;      // 基类
Student stu1;   // 派生类
p1 = stu1;      // 派生类赋给基类

赋值语句将被转换成左边的对象调用的一个方法

p1.operator=(stu1);

将调用基类的赋值运算符Person &operator=(const Person &p)，但只会处理基类成员，可以将派生类对象赋给基类对象，但只涉及基类的成员。

  1. 将基类赋给派生类对象
Person p1;      // 基类
Student stu1;   // 派生类
stu1 = p1;      // 基类赋给派生类

上述代码将转换为

stu1.operator(p1);

将调用派生类的赋值运算符Student & operator(const Student &)，派生类不能自动引用基类对象，所以上述代码会报错。

解决办法:

  1. 定义转换构造函数
Student(const Person &);

转换构造函数可以接受一个类型为基类的参数。也可以添加其他参数，但其他参数必须都有默认值

Teacher(const Person& p, const char *subject = "Chinese");
  1. 定义一个用于将基类赋给派生类的赋值运算符:
Student & Student::operator=(const Person &) {...}
  1. 使用显示强制类型转换
Person p1;      // 基类
Student stu1;   // 派生类
stu1 = (Student)p1;      // 基类赋给派生类

私有成员和保护成员

对于派生类而言，保护成员类似于公有成员；但对于外部而言，保护成员与私有成员类似。

派生类可以直接访问基类的保护成员，但只能通过基类的成员函数来访问私有成员。

虚函数

如果希望派生类能够重新定义方法，则应在基类中将方法定义为虚的。

class Person
{
	...
	public:
		virtual void HShowAll() const {...}	// 基类虚函数
	...
};
class Student : public Person
{
	...
	public:
		virtual void HShowAll() const {...}	// 派生类重写基类虚函数
	...
};

void show(const Person& p)
{
	p.HShowAll();
}
Person p;
Student stu1;
show(p);		// 将调用Person类的HShowAll()
show(stu1);		// 将调用Student类的HShowAll()

可见，虚函数可以让对象正确调用相应的方法。

友元函数

由于友元函数并非类成员函数，所以不能继承。如果希望派生类的友元函数能够使用基类的友元函数，可以通过强制类型转换，派生类引用或指针转换为基类引用或指针，然后使用转换后的指针或引用来调用基类的友元函数

std::ostream& operator<<(std::ostream& os, const Student &stu)
{
    os << (const Person &)stu;  // 强转成基类，输出基类部分的内容
    os << "Sex: " << stu.m_sex << std::endl;
    return os;
}

有关使用基类方法的说明

以公有方式派生的类的对象可以通过多种方式来使用基类的方法。

  • 派生类对象可以使用继承而来的公有或保护基类方法，如果派生类没有重新定义该方法。
  • 派生类的构造函数自动调用基类的默认构造函数，如果没有在成员初始化列表中指定其他构造函数。
  • 派生类构造函数显示地调用成员初始化列表中指定的基类构造函数。
  • 派生类方法可以使用作用域解析运算符::来调用公有的和受保护的基类方法。
  • 派生类的友元函数可以通过强制类型转换，将派生类引用指针或指针转换为基类引用或指针，然后使用该引用或指针来调用基类的友元函数。
Hyunqi
关注
专栏目录
如何设计一个C++的类？
weixin_55751709的博客
09-19 1364
如何设计一个C++的类？
C++课程设计总结C++课程设计总结
06-22
首先，课程设计的目标是让学生掌握C++编程语言，特别是其面向对象的特性，如类的定义和对象的创建。在这个项目中，学生可能需要定义数据结构来存储火车票信息，包括火车线路、出发时间、到达时间、票价等。这可能...
C++ 类设计步骤
qq_18507467的博客
05-15 2462
指定类设计分为两步： 第一步：提供类的声明。 类声明类似结构声明，可以包括数据成员和函数成员。声明有私有部分，在其中声明的成员只能通过成员函数进行访问；声明还有公有部分，在其中声明的成员可被使用类对象的程序直接访问。 通常，数据成员被放在私有部分中，成员函数放在公有部分中，因此典型的类声明格式如下： class classname { private: data membe...
c++中类的设计
heyi3366的博客
05-21 1994
在C++中，类是一种数据类型。客观事物是复杂的，要描述它必须从多方面进行，也就是用不同的数据类型来描述不同的方面。
C++ 类设计规则及注意事项
xiaogangjava的博客
09-14 968
C++ 类设计规则及注意事项 一、概述 C++可用于解决各种类型的编程问题，但不能将类设计简化成带编号的例程。下面将简单介绍类设计中的部分设计规则及 注意事项。 二、编译器生成的成员函数 编译器会自动生成一些公有成员函数—特殊成员函数。这表明这些成员函数很重要，下面将一一说明回顾这些成员函数， 并做简单记录。 2.1 默认构造函数 默认构造函数要么没有参数，要么所有的参数都有默认值： <1> 如果没有定义任何构造函数，编译器将定义默认构造函数，让使用者能够创建对象。假设Star是一个类，则下述代
c++ 类总结
weixin_60413769的博客
03-13 1083
这里是Joe本人的学习笔记，如果能帮助到你，那我受宠若惊！ 不知不觉学习c++类已经一周多了，这里给出我的总结，作为以后的复习资料。 类的基本知识 类的成员函数： 返回值类型 类名 ：： 函数成员名（参数表） { 函数体 } void Clock::set(int a,int b,int c){ 函数体 } 构造函数： 没有返回值，函数名与类名相同， Clock::Clock(int a,int b,int c){ 函数体 } 复制构造函数：
C++ 常见设计模式总结
qq_41952309的博客
08-22 2047
c++ 常见设计模式整理。
C++程序设计 —— 实验一：类与对象
DreamWendy的博客
10-12 2466
目录 一、构造函数 二、析构函数 三、运算符重载 四、友元函数 一、构造函数 1、CMatrix():不带参数的构造函数 2、CMatrix(intnRow,intnCol,double*pData=NULL):带行、列及数据指针等参数的构造函数,并且参数带默认值 3、CMatrix(constchar*strPath):带文件路径参数的构造函数 4、CMatrix(constCMatrix&m):拷贝构造函数 5、此外会用列表初始化成员变量...
C++设计模式介绍、分类与设计模式原则
hanxiaoyong_的博客
05-24 2902
一、设计模式定义 二、设计模式的优点 三、设计模式缺点 四、设计模式中的抽象思维 五、抽象的方法 六、设计模式应用场景 七、设计模式分类 八、设计模式八大原则 附加知识 （1）C++面向对象三种访问修饰符 （2）父类析构函数必须为虚函数 （3）override关键字使用 （4）final关键字使用 （5）父类对象可以与子类对象相互转化吗 （6）虚函数、虚函数表介绍
C++设计模式总结
长期更新自学笔记
09-06 4761
一、单例模式 一个类不管常见多少次对象，永远只能得到该类型一个对象的实例 // p1、p2、p3指向同一对象 A* p1 = new A(); A* p2 = new A(); A* p3 = new A(); 饿汉式单例模式： 还没有获取实例对象，实例对象就已经产生了 优点：线程安全。对象存放在数据段，main函数还没有开始执行，对象就已经初始化好了，一定是线程安全的。 缺点： 获取在软件启动的时候，并没有使用到这个对象，然而这个对象已经产生，这就比较浪费资源。 #include<iostream
课程设计总结+C++学习总结
m0_57659214的博客
07-25 1675
纲要 1、C++界面设计 控制弹出窗口的颜色 控制界面的大小 2、C语言易出错处总结 3、C++格式化输出总结
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
C++设计模式各种模式总结
12-23
C++设计模式各种模式总结
C++课程设计之宾馆客房管理系统源码.zip
05-29
总结，C++课程设计的宾馆客房管理系统是理论与实践的完美结合，它展示了C++在处理实际问题时的强大能力。通过这个项目，学生不仅可以深入理解C++编程，还能学习到软件工程的实践经验，如需求分析、系统设计、代码...
C++与QML的数据交互
qq_50679120的博客
09-11 464
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 237
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言从头学59——学习头文件math.h（二）
最新发布
m0_72128260的博客
09-11 432
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 872
set、map仿STL模拟实现
C++位图的实现与详解
2301_80468112的博客
09-09 657
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
C++程序设计基础-对象与类的探索
总结，C++程序设计中的对象使用涉及到类的设计、对象的实例化、成员的访问以及面向对象的核心概念如封装、继承和多态。理解并熟练应用这些概念是成为有效C++程序员的关键。谭浩强的《C++程序设计》会详细讲解这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值