当前位置：首页 > news >正文

怎样保存网站资料做证据/域名查询站长查询

news 文章来源：https://blog.csdn.net/2301_80840905/article/details/139454850 2025/3/18 8:17:01

怎样保存网站资料做证据,域名查询站长查询,网页设计培训学些什么,网站建设月总结阿尼亚全程陪伴大家学习~ 前言每个程序员在开发新系统时，都希望能够利用已有的软件资源，以缩短开发周期，提高开发效率。为了提高软件的可重用性(reusability)，C提供了类的继承机制。 1.继承的概念继承： 指在现有…

阿尼亚全程陪伴大家学习~

前言

每个程序员在开发新系统时，都希望能够利用已有的软件资源，以缩短开发周期，提高开发效率。为了提高软件的可重用性(reusability)，C++提供了类的继承机制。

1.继承的概念

继承：指在现有类的基础上建立一个新的类。现有类称为基类或父类，新建类称为派生类或子类。对于父类与子类，人们也常说子类继承了父类，或者父类派生了子类。

语法：class 子类（派生类）：继承方式父类（基类）

现在我们一起来看一下具体的实现

#include<iostream>
using namespace std;
//基础界面
class BasePage
{void left(){cout << "Java,C++,Python,C...." << endl;}void right(){cout << "右界面" << endl;}void head(){cout << "头部界面" << endl;}void bottom(){cout << "底部界面" << endl;}
};
//C语言界面
class C 
{
public:void left(){cout << "Java,C++,Python,C...." << endl;}void right(){cout << "右界面" << endl;}void head(){cout << "头部界面" << endl;}void bottom(){cout << "底部界面" << endl;}void Linux(){cout << "Linux" << endl;}
};
//C语言界面
class C :public BasePage
{
public:void Linux(){cout << "Linux" << endl;}
};
//Java界面
class Java :public BasePage
{
public:void JavaSE(){cout << "JavaSE" << endl;}
};

这可以看做一个编程语言学习的主界面，左界面是各种不同语言的分类，这些不同编程语言界面都有主界面的部分，但是他们也有自己独特的部分，主界面是基类，而具体的编程语言界面则是派生类，派生类都继承了父类（基类）所有的成员函数。

2.继承的三种方式

公共（public）继承、保护（protected）继承、私有（private）继承

下面我们一一介绍

2.1公共继承

#include<iostream>
using namespace std;
class A
{
private:int _a = 1;
public:int _A = 10;void A_print(){cout << "_a=" << _a << endl;cout << "_A=" << _A << endl;}
};
class B:public A
{
private:int _b = 2;
public:int _B = 20;void B_print(){cout << "_b=" << _b << endl;}
};
int main()
{B b;b.B_print();b.A_print();return 0;
}

我们发现通过公共继承的方式来继承A类，A类中的打印函数也被继承了，所以B类的对象可以调用A类的成员函数，接下来我们修改一下代码，在B类中访问A类的成员变量

编译器告诉我们_a不可以被访问因为他是A类中的私有成员，而_A可以被访问因为他是A类中的公有成员，那有没有什么方法能让_a也能被访问呢？

有。一种是把_a设置为public成员，另外一种是把_a设置为protected成员（最好的做法），这三种又有什么区别呢？（重要！！！）

*公有（public）成员：

公有成员可以从任何地方被访问，包括类的内部、类的派生类以及类的外部。
把_a设置为公有成员意味着任何地方的代码都可以直接访问它，这通常不是一个好的做法，因为它破坏了封装性（封装性意味着隐藏对象的内部状态以防止它们被外部代码直接访问）。

*私有（private）成员：

私有成员只能在类的内部被访问。
编译器告诉我们_a不可以被访问，因为它被声明为私有成员。这意味着你不能从类的外部或派生类中直接访问它。

*保护（protected）成员：

保护成员可以在类的内部和派生类中被访问，但不能在类的外部被访问。
把_a设置为保护成员意味着你可以在其派生类中访问它，但不能在类的外部直接访问它。这提供了一种在派生类中重用和扩展基类功能的方式，同时保持对外部世界的封装性。

能明白三者的差异，也就很容易理解三种继承方式的差别了

#include<iostream>
using namespace std;
class A
{
private:int _a = 1;
protected:int a = 100;
public:int _A = 10;void A_print()//A类打印函数{cout << "_a=" << _a << endl;cout << "_A=" << _A << endl;cout << "a=" << a << endl;}
};
class B:public A
{
private:int _b = 2;
public:void B_print()//B类打印函数{cout << "_b=" << _b << endl;//cout << "_a=" << _a << endl;//A类私有成员不能被访问cout << "_A=" << _A << endl;//A类公有成员可以被访问cout << "a=" << a << endl;//A类保护成员可以被访问A_print();//A类公有成员可以被访问}
};
int main()
{B b;b.B_print();cout << endl;cout << b._A << endl;//public继承方式，在类的外部能访问类public成员b.A_print();//public继承方式，在类的外部能访问类public成员//cout << b.a << endl;//在类的外部不能访问类protected成员return 0;
}

2.2保护继承

#include<iostream>
using namespace std;
class A
{
private:int _a = 1;
protected:int a = 100;
public:int _A = 10;void A_print()//A类打印函数{cout << "_a=" << _a << endl;cout << "_A=" << _A << endl;cout << "a=" << a << endl;}
};
class B:protected A
{
private:int _b = 2;
public:void B_print()//B类打印函数{cout << "_b=" << _b << endl;//cout << "_a=" << _a << endl;//A类私有成员不能被访问cout << "_A=" << _A << endl;//A类公有成员可以被访问cout << "a=" << a << endl;//A类保护成员可以被访问A_print();//A类公有成员可以被访问}
};
int main()
{B b;b.B_print();//b.A_print();//protected继承方式，在类的外部不能访问类成员return 0;
}

2.3私有继承

#include<iostream>
using namespace std;
class A
{
private:int _a = 1;
protected:int a = 100;
public:int _A = 10;void A_print()//A类打印函数{cout << "_a=" << _a << endl;cout << "_A=" << _A << endl;cout << "a=" << a << endl;}
};
class B:private A
{
private:int _b = 2;
public:void B_print()//B类打印函数{cout << "_b=" << _b << endl;//cout << "_a=" << _a << endl;//A类私有成员不能被访问cout << "_A=" << _A << endl;//A类公有成员可以被访问cout << "a=" << a << endl;//A类保护成员可以被访问//A_print();//A类公有成员可以被访问}
};
int main()
{B b;b.B_print();cout << endl;//cout << b._A << endl;//private继承方式，在类的外部不能访问类public成员//cout << b.a << endl;private继承方式，在类的外部不能访问类protected成员//b.A_print();//private继承方式，在类的外部不能访问类public成员return 0;
}

总结

在类的内部，派生类无论是以哪种方式继承基类，都不能访问基类的private成员，而基类的public成员、protected成员可以被派生类访问

在类的外部，首先需要明确的是无论是基类还是派生类的private成员和protected成员都是不能直接被访问的。而public继承的方式可以通过派生类的对象访问基类的public成员，而private继承的方式和protected继承的方式中，却不可以通过派生类的对象访问基类的public成员（可以这么理解此时基类的public成员分别成了派生类的私有成员和保护成员）。

下图辅助理解

3.继承的对象模型

我们发现B类的大小是16个字节，但是我们之前继承方式当中不是说基类的私有成员派生类不能访问吗？

其实父类中所有非静态成员都会被子类继承，父类中的私有成员属性其实是被编译器隐藏了，因此访问不到，但是确实被继承了下来，下面我们来验证一下

首先我们先打开这个工具（开发人员命令提示符）

指令输入步骤

最终呈现结果

经过验证是不是更可靠了呢

4.派生类的构造函数和析构函数

4.1构造函数

派生类不继承基类的构造函数，在声明派生类时一般应定义自己的构造函数

注意

派生类构造函数的总参数表中的参数，应当包括调用基类构造函数所需的参数派生类构造函数的执行过程是，先调用基类构造函数初始化基类成员，然后对新增成员初始化

#include<iostream>
#include<string>
using namespace std;class Person//基类
{
protected:string _name;//姓名char _sex;//性别int _age;//年龄
public://Person构造函数Person(string name,char sex,int age):_name(name),_sex(sex),_age(age){}void PersonPrint(){cout << "name:" << _name << endl;cout << "sex:" << _sex << endl;cout << "age:" << _age << endl;}
};
//派生类
class Student :public Person
{
private:int _num;//学号
public://Student构造函数Student(string name,char sex,int age,int num):Person(name,sex,age),_num(num){}void StudentPrint(){PersonPrint();cout << "num:" << _num << endl;}
};
int main()
{Student s("liming", 'M', 18, 1001);s.StudentPrint();return 0;
}

4.1.1有子对象的派生类的构造函数

在学习结构体时，我们讲到一个结构体的成员还可以是个结构体变量。派生类也可以有子对象（类类型的成员变量）

#include<iostream>
#include<string>
using namespace std;class Person//基类
{
protected:string _name;//姓名char _sex;//性别int _age;//年龄
public://Person构造函数Person(string name,char sex,int age):_name(name),_sex(sex),_age(age){}void PersonPrint(){cout << "name:" << _name << endl;cout << "sex:" << _sex << endl;cout << "age:" << _age << endl;}
};
//派生类
class Student :public Person
{
private:Person _teacher;//班主任（子对象）int _num;//学号
public://Student构造函数Student(string name,char sex,int age,int num,const Person& teacher):Person(name,sex,age),_num(num),_teacher(teacher){}void StudentPrint(){PersonPrint();//打印学生的信息cout << "num:" << _num << endl;_teacher.PersonPrint();//打印老师的信息}
};
int main()
{Person teacher("zhaoli", 'F', 38);//班主任Student s("liming", 'M', 18, 1001, teacher);//学生s.StudentPrint();return 0;
}

基类构造函数和子对象的书写顺序可以任意

这里有子对象的派生类的构造函数还有另外两种写法

写法一

这种不如引用传参更安全，效率高

写法二

这种写法相对比较麻烦，写的形参更多了

4.1.2派生类构造函数的执行顺序

结论：

先调用基类构造函数，对基类数据成员初始化

再调用子对象类的构造函数，对子对象的数据成员初始化

最后执行派生类构造函数体中的语句，对派生类新增数据成员初始化

验证

4.2析构函数

1.派生类不继承基类的析构函数，在声明派生类时，应当定义自己的析构函数

2.派生类的析构函数只对新增成员进行清理工作，基类、子对象的清理工作仍由它们各自的析构函数负责。

3.在执行派生类的析构函数时，系统会自动调用基类的析构函数和子对象的析构函数，分别对基类和子对象进行清理

4.析构函数的执行顺序与构造函数正好相反先执行派生类自己的析构函数，对派生类新增成员进行清理；然后调用子对象的析构函数，对子对象进行清理；最后调用基类的析构函数，对基类进行清理。

析构顺序验证

我们发现Person类只构造了两次，居然析构了三次，这是为什么呢？

其实是因为默认的Person类拷贝构造函数，现在我们显示写一下他的拷贝构造函数来验证一下

#include<iostream>
#include<string>
using namespace std;
class Person//基类
{
protected:string _name;//姓名char _sex;//性别int _age;//年龄
public:void PersonPrint(){cout << "name:" << _name << endl;cout << "sex:" << _sex << endl;cout << "age:" << _age << endl;}//Person构造函数Person(string name,char sex,int age) :_name(name), _sex(sex), _age(age){cout << "Person构造" << endl;}//Person拷贝构造Person(const Person& p){_name = p._name;_sex = p._sex;_age = p._age;cout << "Person拷贝构造" << endl;}~Person(){cout << "~Person析构" << endl;}
};
class Student :public Person
{
private:Person _teacher;//班主任（子对象）int _num;//学号
public://Student构造函数Student(string name, char sex, int age, int num, const Person& teacher):Person(name, sex, age), _num(num), _teacher(teacher){cout << "Student构造" << endl;}void StudentPrint(){PersonPrint();//打印学生的信息cout << "num:" << _num << endl;_teacher.PersonPrint();//打印老师的信息}~Student(){cout << "~Student析构" << endl;}
};
int main()
{Person teacher("zhaoli", 'F', 38);//班主任cout << "*******************************" << endl;Student s("liming", 'M', 18, 1001, teacher);//学生//s.StudentPrint();return 0;
}