C++继承机制学习笔记

最新推荐文章于 2023-02-06 21:24:00 发布
最新推荐文章于 2023-02-06 21:24:00 发布
阅读量395 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44653420/article/details/127677392
版权

C++继承机制

一、继承的作用

  • 代码的复用
  • 扩展功能
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

// 继承的作用1：代码的复用  2 扩展功能
class Father
{
public:
	void func1()
	{
		cout << "高颜值" << endl;
	}
	void func2()
	{
		cout << "有钱" << endl;
	}
};

class Son:public Father
{
public:
	void fun3()
	{
		cout << "油菜花" << endl;
	}
};

void test()
{
	Son s;
	s.func1();
	s.func2();
	s.fun3();
}

int main()
{
	test();
	return EXIT_SUCCESS;
}

二、继承的方式

2.1 继承方式种类

  • 公有继承
  • 私有继承
  • 保护继承

2.2 子类从父类继承过来的成员的权限

2.2.1 公有继承
  • 公有成员:父类的公有属性成员进入子类还是公有
    类内和类外都可以访问私有成员
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:Father
{
public:
	void func()
	{
		cout << a <<endl;// 从类内进行访问 OK
	}
};

void test()
{
	Son1 s;
	s.a;// 从类外进行访问 OK
}

int main()
{
    test();

	return EXIT_SUCCESS;
}
  • 私有成员：父类的私有成员进入子类还是私有的成员

类内和类外都不可以访问私有成员

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:Father
{
public:
	void func()
	{
		//cout << a <<endl;// 从类内进行访问
		cout << b << endl;//私有成员不可以进行访问 报错
	}
};

void test()
{
	Son1 s;
	s.b;// 从类外进行访问私有成员 报错

}

int main()
{
	test();

	return EXIT_SUCCESS;
}
  • 保护成员：父类的成员到子类还是保护成员
    类内可以访问私有成员 类外不可以访问私有成员
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:Father
{
public:
	void func()
	{
		//cout << a <<endl;// 从类内进行访问
		cout << c << endl;//子类可以访问保护成员  不报错
	}
};

void test()
{
	Son1 s;
	s.b;// 从类外进行访问保护成员  报错
}

int main()
{
	test();
	return EXIT_SUCCESS;
}
2.2.2 保护继承
  • 公有属性

父类公有属性 子类保护属性

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};

class Son1:protected Father
{
public:
	void func()
	{
		cout << a <<endl;// 从类内进行访问 OK
	}
};

void test()
{
	Son1 s;
	s.a;// 从类外进行访问保护成员  报错
}

int main()
{
	test();
	return EXIT_SUCCESS;
}
  • 私有属性

父类私有属性 子类还是私有属性

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:protected Father
{
public:
	void func()
	{
		cout << b <<endl;// 从类内进行访问 报错  仍然是私有属性
	}
};

void test() 
{
	Son1 s;
	s.b;// 从类外进行访问保护成员  报错  
}

int main()
{
	test();

	return EXIT_SUCCESS;
}
  • 保护属性
    父类保护属性 子类仍然是保护属性
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:protected Father
{
public:
	void func()
	{
		cout << c <<endl;// 从类内进行访问 OK
	}
};

void test() 
{
	Son1 s;
	s.c;// 从类外进行访问保护成员  报错  
}

int main()
{
	test();

	return EXIT_SUCCESS;
}
2.2.3 私有继承

  • 父类的公有属性成员 到子类是保护

  • 父类的私有属性成员 到子类还是私有

  • 父类的保护属性成员 到子类还是保护

  • 公有属性

公有属性变成保护属性

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:private Father
{
public:
	void func()
	{
		cout << a <<endl;// 从类内进行访问 OK
	}
};

void test() 
{
	Son1 s;
	s.a;// 从类外进行访问保护成员  报错    变成保护属性
}

int main()
{
	test();

	return EXIT_SUCCESS;
}
  • 私有属性
    父类的私有属性成员 到子类还是私有属性成员
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:private Father
{
public:
	void func()
	{
		cout << b <<endl;// 从类内进行访问 ERROR
	}
};

void test() 
{
	Son1 s;
	s.b;// 从类外进行访问保护成员  报错  还是私有属性
}

int main()
{
	test();

	return EXIT_SUCCESS;
}
  • 保护属性
    父类的保护属性 子类还是保护属性
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	int a;

private:
	int b;

protected:
	int c;
};


class Son1:private Father
{
public:
	void func()
	{
		cout << c <<endl;// 从类内进行访问 OK
	}
};

void test() 
{
	Son1 s;
	s.c;// 从类外进行访问保护成员  报错 还是保护属性
}

int main()
{
	test();
	return EXIT_SUCCESS;
}

三、继承中的构造和析构的调用

  • 继承调用顺序
    先调用父类的构造函数 在调用子类的构造函数 析构函数调用顺序相反
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	Father() {
		cout << "构造函数" << endl;
	}

	~Father() {
		cout << "析构函数" << endl;
	}
};

// 先调用父类的构造函数 在调用子类的构造函数  析构函数调用顺序反之
class Son :public Father
{
public:
	Son() {
		cout << "Son构造函数" << endl;
	}

	~Son()
	{
		cout << "Son析构函数" << endl;
	}
};

void test()
{
	Son s;
}

int main()
{
	test();

	return EXIT_SUCCESS;
}
  • 继承和组合的混搭

先调用父类的构造，然后调用成员对象的构造，最后调用本身的构造，析构函数反之

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		cout << "A的构造函数" << endl;
	}

	~A()
	{
		cout << "A的析构函数" << endl;
	}
};

class B
{
public:
	B()
	{
		cout << "B的构造函数" << endl;
	}

	~B()
	{
		cout << "B的析构函数" << endl;
	}
};

class C
{
public:
	C()
	{
		cout << "C的构造函数" << endl;
	}

	~C()
	{
		cout << "C的析构函数" << endl;
	}
};


class D:public A
{
public:
	D()
	{
		cout << "D的构造函数" << endl;
	}

	~D()
	{
		cout << "D的析构函数" << endl;
	}

public:
	B b;
	C c;
};

void test()
{
	D d;
}

int main()
{
	test();

	return EXIT_SUCCESS;
}

先调用A的构造函数，在调用B C 的构造函数 最后调用D的构造函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	Father()
	{
		cout << "Father的构造函数" << endl;
	}

	~Father()
	{
		cout << "Father的析构函数" << endl;
	}
};

class Son:public Father
{
public:
	Son()
	{
		cout << "Son的构造函数" << endl;
	}

	~Son()
	{
		cout << "Son的析构函数" << endl;
	}
};

class A
{
public:
	A()
	{
		cout << "A的构造函数" << endl;
	}
	~A()
	{
		cout << "A的析构函数" << endl;
	}
public:
	Son s;
};

class B
{
public:
	B()
	{
		cout << "B的构造函数" << endl;
	}

	~B()
	{
		cout << "B的析构函数" << endl;
	}
};

class C
{
public:
	C()
	{
		cout << "C的构造函数" << endl;
	}

	~C()
	{
		cout << "C的析构函数" << endl;
	}
};


class D:public A
{
public:
	D()
	{
		cout << "D的构造函数" << endl;
	}

	~D()
	{
		cout << "D的析构函数" << endl;
	}

public:
	B b;
	C c;
};

void test()
{
	D d;
}

int main()
{
	test();

	return EXIT_SUCCESS;
}

先调用父类A的成员对象的父类的构造函数

三、继承中同名成员的处理方法

  • 当子类和父类有相同的同名成员的时候，子类会隐藏父类的同名成员
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	Father()
	{
		a = 10;
	}
public:
	int a;
};

class Son:public Father
{
public:
	Son()
	{
		a = 20;
	}
public:
	int a;
};

void test()
{
	Son s;
	cout << s.a << endl;// 访问的是自己的成员变量
}

int main()
{
	test();
	return EXIT_SUCCESS;
}

可以通过作用域访问父类的同名成员变量

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	Father()
	{
		a = 10;
	}
public:
	int a;
};

class Son:public Father
{
public:
	Son()
	{
		a = 20;
	}
public:
	int a;
};

void test()
{
	Son s;
	cout << s.a << endl;// 访问的是自己的成员变量

	// 可以通过作用域来访问父类的成员变量
	cout << s.Father::a << endl;
}

int main()
{
	test();
	return EXIT_SUCCESS;
}
  • 当子类和父类有同名函数的时候，父类的所有函数重载都会被隐藏完毕
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	Father()
	{
		a = 10;
	}

	void func()
	{
		cout << "Father func" << endl;
	}

	void func(int a)
	{
		cout << "Father func1" << endl;
	}

	void func(int a,int b)
	{
		cout << "Father func a b" << endl;
	}

public:
	int a;
};

class Son:public Father
{
public:
	Son()
	{
		a = 20;
	}

	void func()
	{
		cout << "Son func" << endl;
	}

public:
	int a;
};

void test()
{
	
	Son s;
	s.func();// 调用的是子类的 同名成员函数
	s.func(1);// 不行  子类没有和父类的同名成员函数
}
 
int main()
{
	test();
	return EXIT_SUCCESS;
}

可以通过作用域来访问同名函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	Father()
	{
		a = 10;
	}

	void func()
	{
		cout << "Father func" << endl;
	}

	void func(int a)
	{
		cout << "Father func1" << endl;
	}

	void func(int a,int b)
	{
		cout << "Father func a b" << endl;
	}

public:
	int a;
};

class Son:public Father
{
public:
	Son()
	{
		a = 20;
	}

	void func()
	{
		cout << "Son func" << endl;
	}

public:
	int a;
};

void test()
{
	
	Son s;
	s.func();// 调用的是子类的 同名成员函数
	s.Father::func(1);// 通过作用域进行访问
}
 
int main()
{
	test();
	return EXIT_SUCCESS;
}

四、继承中的静态成员特性

静态成员可以被继承

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	static int mA;
};

// 静态成员类内部声明  类外进行访问
int Father::mA = 10;

class Son :public Father
{
public:

};

void test()
{
	Son s;
	cout << s.mA << endl;// 静态成员可以被继承

}
 
int main()
{
	test();
	return EXIT_SUCCESS;
}

子类同名的静态成员会覆盖掉父类的同名静态成员

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	static int mA;
};

// 静态成员类内部声明  类外进行访问
int Father::mA = 10;

class Son :public Father
{
public:
	static int mA;
};


// 子类同名的静态成员会覆盖父类的同名静态成员
int Son::mA = 100;

void test()
{
	Son s;
	cout << s.mA << endl;// 静态成员可以被继承 

}

int main()
{
	test();
	return EXIT_SUCCESS;
}

继承中的静态成员函数中，当子类和父类同名函数时候，父类的所有重载静态函数都会被隐藏

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	// 静态成员函数
	static void func()
	{
		cout << "Father func()" << endl;
	}

	// 静态成员函数重载
	static void func(int a)
	{
		cout << "Father func(int a)" << endl;
	}

	static void func(int a,int b)
	{
		cout << "Father func(int a,int b)" << endl;
	}

public:
	static int mA;
};

// 静态成员类内部声明  类外进行访问
int Father::mA = 10;

class Son :public Father
{
public:
	static void func()
	{
		cout << "Son func()" << endl;
	}

public:
	static int mA;
};


// 子类同名的静态成员会覆盖父类的同名静态成员
int Son::mA = 100;

void test()
{
	Son s;
	s.func();
	s.func(1);// 保存  父类的同名静态函数会被隐藏

}
 
int main()
{
	test();
	return EXIT_SUCCESS;
}
  • 从父类继承过来的静态成员变量是父类的静态成员变量 不是拷贝过来的
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	// 静态成员函数
	static void func()
	{
		cout << "Father func()" << endl;
	}

	// 静态成员函数重载
	static void func(int a)
	{
		cout << "Father func(int a)" << endl;
	}

	static void func(int a,int b)
	{
		cout << "Father func(int a,int b)" << endl;
	}

public:
	static int mA;
};

// 静态成员类内部声明  类外进行访问
int Father::mA = 10;

class Son :public Father
{
public:
	static void func()
	{
		cout << "Son func()" << endl;
	}

public:
	static int mA;
};


// 子类同名的静态成员会覆盖父类的同名静态成员
int Son::mA = 100;

void test()
{
	Son s;
	cout << s.mA << endl;

	// 通过子类更改父类的静态成员变量
	s.Father::mA = 200;
	cout << Father::mA << endl;

	// 通过打印地址 查看是否更改同一个变量地址
	cout << &(s.Father::mA) << endl;
	cout << &(Father::mA) << endl;

}
 
int main()
{
	test();
	return EXIT_SUCCESS;
}

五、多继承

  • 多继承是一个类有两个以上的父类
  • 多继承的问题是，当父类中有同名的成员时，子类会产生二义性问题
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father1
{
public:
	int bmw;
};

class Father2
{
public:
	int bmw;
};

class Son :public Father1, public Father2
{

};

void test()
{
	Son s;// 产生二义性问题
}
 
int main()
{
	test();
	return EXIT_SUCCESS;
}

六、菱形继承

两个派生类同时继承同一个基类，而又有某个类同时继承两个派生类，这种继承被称为菱形继承，或者钻石型继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qkgXnDXK-1667477462245)(…/images/3889f11618c5e7ad2f0bc10cfb5f6952accdf71072fbcf9ef796f569ae8903f5.png)]

虚基类的定义：被虚继承的基类称之为虚基类

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

// 称之为虚基类
class Animal
{
public:
	Animal()
	{
		mA = 100;
	}
public:
	int mA;
};

// 虚继承
class Sheep :virtual public Animal
{

};

// 虚继承
class Camel :virtual public Animal
{

};

class SheepCamel :public Sheep, public Camel
{
	// 多继承
	// 使用虚继承的方法解决菱形继承中的二义性问题
	

};

void test()
{
	SheepCamel s;

	// 直接使用组类的成员变量
	cout << s.mA << endl;// 打印100
	
}
 
int main()
{
	test();
	return EXIT_SUCCESS;
}

两个父类中有组类中的数据，然后子类会继承两个父类的数据，会产生二义性问题

解决二义性问题的关键是使用父类虚继承组类，使用virtual关键字

虚继承的原理：

  • 编译给类添加了一个指针，指针指向类似于表的组织，该表记录了该指针距离变量的偏移量
  • 当子类多继承两个父类，那么只有一份成员变量，然后又有两个指针，只有一份成员变量，所以不会产生二义性问题

七、通过指针访问成员变量

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

// 称之为虚基类
class Animal
{
public:
	Animal()
	{
		mA = 100;
	}
public:
	int mA;
};

// 虚继承
class Sheep :virtual public Animal
{

};

// 虚继承
class Camel :virtual public Animal
{

};

class SheepCamel :public Sheep, public Camel
{
	// 多继承
	// 使用虚继承的方法解决菱形继承中的二义性问题

};

void test()
{
	SheepCamel s;
	cout << s.mA << endl;// 打印100
	
}

void test1()
{
	Sheep s;
	cout << *((int*)*(int*)&s + 1) << endl;

	// 将类型转换为Animal指针类型
	cout << ((Animal*)((char*)&s + *((int*)*(int*)&s + 1)))->mA << endl;
}
 
int main()
{
	test1();
	return EXIT_SUCCESS;
}
少写代码少看论文多多睡觉
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++学习笔记之继承
01-08
继承：是类之间定义的一种重要关系。 按照生活中的思考方式的话，就是继承老一辈的手艺并且在新的一辈中得到创新与传承，这里只不过是用在了类的关系上面，即老类与新类，父类与子类 继承举例： //写一个继承 //父类...
C++继承
qq_45604814的博客
04-01 863
一.继承概念 继承就是在原有成员基础上添加特有的成员形成派生类 1.继承的作用 目的：代码重用提高执行效率 关键词：基类（父类）、派生类（子类） 意义：子类拥有父类的成员、子类拥有父类没有的特性、子类是一种特殊的父类（子类可以当做父类使用） 2.继承注意点 不能继承父类的构造析构和友元函数 子类拥有父类所有成员属性和行为 一个类可以有多个基类，也可以有多个派生类 3.继承 派生类成员包括两大部分：一是从基类继承下来的成员（与基类拥有共同的特性）、二是本身独有的特性 格式： clas
C++之继承详解(万字讲解)
be_a_struggler的博客
11-11 5304
C++继承详解，继承概念与定义，六大默认函数，基类和派生类赋值转换，继承中的作用域，继承与友元，继承与静态成员，菱形虚拟继承，菱形继承，菱形继承的深度剖析
C++继承简单介绍
m0_64221480的博客
02-03 585
继承简单介绍
千锋教育C++Markdown学习笔记
最新发布
08-01
这是跟着B站千锋教育学习C++的课程笔记，采用Markdown格式记录，没有图片，全是文字和代码，紧跟着上一次我发的C的课程笔记。
C++学习笔记.pdf
08-12
C++学习笔记
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
c++核心之继承
qq_46518045的博客
05-18 560
继承 1，继承的好处：可以减少重复的代码 派生类里面的成员，包含两部分： a,一类是从基类中继承过来的，一类是自己增加的成员。 b,从基类继承过来的表现其共性，而新增的成员体现其个性。 2，继承方式有三种 a,public 父类：继承下来的都可以访问 b,protected 父类：继承过后子类中的继承全部变为protected c,private 父类：继承过后子类中的继承全部变为private. 注意子类只能访问父类中的public和protected,不能访问private权限 eg: #include
C++继承的作用
qq_40776805的博客
09-08 681
扩展已经存在的代码块，主要目的代码块的复用;
C++程序设计——继承
m0_63020222的博客
02-06 551
C++中的继承：概念及定义、赋值兼容规则、继承中的作用域、派生类的默认成员函数、继承与友元、继承与静态成员、菱形继承和菱形虚拟继承、继承与组合
C++之继承最详讲
weixin_45897952的博客
05-02 4689
目录 1.继承的概念 2.继承的定义 3.继承权限 3.1、子类以public方式继承父类 3.2、子类以protect方式继承 3.3、子类以private方式继承 3.4、class关键字没有给出继承方式默认的继承方式是私有的继承方式 3.5、struct关键字没有给出继承方式默认的继承方式是公共的继承方式 3.6、那么我们可以就此总结一下class和struct的区别 3.7、关于继承方式大总结 4.基类和派生类对象赋值转换 4.1、派生类对象可以赋..
【C++】继承
Edward_Asia的博客
04-08 8628
目录 1. 概念 2. 定义 2.1. 使用格式 2.2. 继承方式与限定修饰符 3. 基类和派生类对象赋值转换 (public继承) 4. 继承中的作用域 5. 子类类的默认成员函数 6. 继承与友元 7. 静态成员 8. 菱形继承和虚继承 8.1 菱形继承 8.2 虚继承(virtual) 8.3 虚继承解决数据冗余和二义性的原理 9. 继承总结、继承与组合 9.1总结 9.2 继承与组合 1. 概念 继承(inheritance)机制是面向对象程序设..
C++：继承的作用
qq_42745340的博客
03-13 1048
2-1 为什么继承 内存中的对象： 2-2 代码演示 Person.h #include <string> using namespace std;//class也在std里面 class Person { public: Person(); ~Person(); void eat(); string m_strName; int m_iAge; }; P...
C++ 继承详解
玄鸟轩墨的博客
07-21 3675
在谈着这个之前,我们需要先说说C++的几大特性,封装继承,多态…注意,实不置这三种,只不过他们是基础罢了,大家面试的时候注意一点.我们已经学过了封装,今天就开始继承吧,我们最好按照简单的学习来,这里的语法可能有点难,但是我们用的时候一定要偏简单一点.我查了一些资料,里面对继承的概念简述的还是比较详细的.继承（英语inheritance）是面向对象软件技术当中的一个概念。如果一个类别B“继承自”另一个类别A，就把这个B称为“A的子类”，而把A称为“B的父类别”也可以称“A是B的超类”。子类父类。...
C++继承（一）继承的格式与三种不同继承方式， 三种继承的示意图，简单继承案例说明继承作用 ，
qq_51004011的博客
07-01 1525
使用公共继承后，父类中的公共属性，在子类中也属于公共属性，父类中的保护属性，在子类中也属于保护属性。 那么对于保护继承来说，子类保护继承于父类后，会将父类中的公共属性与保护属性下的数据都继承到他自己的保护权限下。 对于私有继承来说：子类会将父类中所有的属性全都继承到子类的私有权限下。 ......
C++中继承的概念和意义
年少轻狂，幸福时光
08-08 9883
    在C++中，类与类之间的关系有组合与继承两种，以生活中的例子来举例，组合就好比电脑这个类由主板、CPU、内存、硬盘等这些类组成的，属于整体与部分的关系，如下图: 而继承则好比电脑与苹果电脑、戴尔电脑之间的关系，也叫父子关系，电脑为父类，苹果电脑与戴尔电脑为子类，如下: 先来讨论类的组合关系：     - 将其他类的对象作为当前类的成员使用     - 成员对象与当前类的对象生命周期相同 ...
C++继承详解
博客记录学习轨迹，方便日后复习
09-03 3379
在现实生活中我们会遇到不同身份的人具有相同属性，比如说在一个学校的管理系统中，我们有教师身份、学生身份等等，他们各自都有如下的属性：我们可以发现，教师和学生除了入职年限和入学年限这一属性不同，其他的姓名、年龄、性别属性是相同的，于是我们可以把不同身份的相同属性提取出来，成为一个公共的属性。在C++中引入了继承的概念，将不同类的相同属性提取出来成为一个独立的公共类，其他类只需要继承这个公共类就可以使用共同的属性。
零基础c++学习笔记pdf
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

少写代码少看论文多多睡觉

求打赏，求关注，求点赞

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值