class Person {
public:
传统方式初始化
//Person(int a, int b, int c) {
// m_A = a;
// m_B = b;
// m_C = c;
//}
//初始化列表方式初始化
Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
void PrintPerson() {
cout << "mA:" << m_A << endl;
cout << "mB:" << m_B << endl;
cout << "mC:" << m_C << endl;
}
private:
int m_A;
int m_B;
int m_C;
};
int main() {
Person p(1, 2, 3);
p.PrintPerson();
system("pause");
return 0;
}
6）类对象作为类成员
可以利用初始化列表来告诉编译器调用哪个对象成员的构造函数！！！
对象与类成员的构造与析构顺序可以参考栈的特性：先构造对象成员再构造自身，析构则与构造顺序相反！（先有零件后有整体）
7）静态成员
静态成员包括静态成员变量和静态成员函数。
- 静态成员变量：所有的对象共享一份数据（一个地址），在编译阶段分配内存，类内声明类外初始化
- 静态成员函数：所有的对象共享同一个函数（一个地址），静态成员函数只能访问静态成员变量（因为这个函数是共享的，不知道要改的非静态属性是哪个对象的）！
- 注意：私有的静态成员变量也可以在类外初始化但不能访问类外。静态成员函数有两种访问方式，第一种是通过对象，第二种是通过类名。
void test01()
{
//静态成员变量两种访问方式
//1、通过对象
Person p1;
p1.func();
//2、通过类名
Person::func();
//Person::func2(); //私有权限访问不到
}
2.析构函数
析构函数没有返回值也不写void，不可以有参数因此不能重载，在对象销毁前会调用一次。
通过析构函数释放掉对象开辟的堆区属性。
4.3 C++对象模型和this指针
1.成员变量和成员函数分开存储
- 只有非静态成员变量才属于类的对象上，存储在对象的地址中。
- 空对象占有1B，用于标识出有这么一个空对象。当对象不为空时，它的存储空间只包括非静态成员变量且不包括这1B！
- 所有的成员函数都是只有一份的而非每个对象都有一份。当调用时依靠this指针识别是哪个对象调用的。
class Person {
public:
Person() {
mA = 0;
}
//非静态成员变量占对象空间
int mA;
//静态成员变量不占对象空间
static int mB;
//函数也不占对象空间，所有函数共享一个函数实例
void func() {
cout << "mA:" << this->mA << endl;
}
//静态成员函数也不占对象空间
static void sfunc() {
}
};
int main() {
cout << sizeof(Person) << endl;
system("pause");
return 0;
}
2.this指针概念
- this指针指向被调用的成员函数所属的对象。
- this指针隐含在每一个非静态成员函数内。
- this指针本质是一个指针常量，指针的指向不可修改。Person* const this;
- 用途：
- 当形参和成员变量同名时可以用this指针区分。
- 在类的非静态成员函数中返回对象本身可以使用：return *this;(解引用后返回对象本身)
#include<iostream>
using namespace std;
class Person
{
public:
Person(int age)
{
//1、当形参和成员变量同名时，可用this指针来区分
this->age = age;
}
Person& PersonAddPerson(Person p)
{
this->age += p.age;
//返回对象本身
return *this;
}
int age;
};
void test01()
{
Person p1(10);
cout << "p1.age = " << p1.age << endl;
Person p2(10);
p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
cout << "p2.age = " << p2.age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
这里有两个需要注意的点:
第一：为什么可以连续调用这么多次？
p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
第二：为什么返回引用对象？
Person& PersonAddPerson(Person p)
{
this->age += p.age;
//返回对象本身
return *this;
}
首先这里使用了引用对象，所以可以把p2.PersonAddPerson(p1)看作是p2的一个别名，操作的一直是p2对象指向的地址。也就是引用章节讲的引用作函数返回值时返回的就是return对象的一个别名（甚至整个调用的函数就是它的别名）。
只有返回类型为引用才能返回本体，否则将调用拷贝构造返回一个新的对象。
如果这里的函数返回类型为void则无法调用三次！！！
如果这里的函数返回类型为Person则每次都将产生一个新的对象，而不是在p2上操作！！！
3.空指针访问成员函数
C++中空指针也可以调用类中的成员函数，但一定要注意有没有用到this指针，如果用到了就要加一个判断是否为空指针的环节，否则this无法指向空对象就会报错！！！
//空指针访问成员函数
class Person {
public:
void ShowClassName() {
cout << "我是Person类!" << endl;
}
void ShowPerson() {
if (this == NULL) {
return;
}
cout << mAge << endl;
}
public:
int mAge;
};
void test01()
{
Person * p = NULL;
p->ShowClassName(); //空指针，可以调用成员函数
p->ShowPerson(); //但是如果成员函数中用到了this指针，就不可以了
}
int main() {
test01();
system("pause");
return 0;
}
4.const****修饰成员函数
常函数：
- 成员函数后加const后我们称为这个函数为常函数
- 常函数内不可以修改成员属性，不做赋值和改值操作
- 成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象：
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数（因为普通成员函数可以修改成员属性，不能让常对象间接修改成员属性）
常对象和常函数是配套的！！！！！
class Person {
public:
Person() {
m_A = 0;
m_B = 0;
}
//this指针的本质是一个指针常量，指针的指向不可修改
//如果想让指针指向的值也不可以修改，需要声明常函数
void ShowPerson() const {
//本质的意思就是const Type* const this; 但前面这个const思来想去最后加在了{}前面
//this = NULL; //不能修改指针的指向 Person* const this;
//this->mA = 100; //但是this指针指向的对象的数据是可以修改的
//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
this->m_B = 100;
}
void MyFunc() const {
//mA = 10000;
}
public:
int m_A;
mutable int m_B; //可修改 可变的
};
//const修饰对象 常对象
void test01() {
const Person person; //常量对象
cout << person.m_A << endl;
//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
//常对象访问成员函数
person.MyFunc(); //常对象不能调用const的函数
}
int main() {
test01();
system("pause");
return 0;
}
4.4 友元
假如想让某一些类内的私有数据被类外的一些函数或者类所访问，我们就需要用到友元（好朋友）。即友元的目的就是让一个类或者函数访问另一个类中的私有成员。
1.友元的三种实现
友元的三种实现：全局函数、类、成员函数。
1）全局函数
#include<iostream>
using namespace std;
class Building
{
//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
friend void goodGay(Building* building); //friend 函数声明;
public:
Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom; //卧室
};
void goodGay(Building* building)
{
cout << "好基友正在访问： " << building->m_SittingRoom << endl;
cout << "好基友正在访问： " << building->m_BedRoom << endl;
}
void test01()
{
Building b;
goodGay(&b);
}
int main() {
test01();
system("pause");
return 0;
}
2）类
#include<iostream>
using namespace std;
class Building;
class goodGay
{
public:
goodGay();
void visit();
void visitOut(Building* b);
private:
Building* building;
};
class Building
{
//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
friend class goodGay;
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
//类外实现构造函数和成员函数
Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
building = new Building;
}
//友元声明后可以访问类内类成员对象中的私有属性
void goodGay::visit()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
cout << "好基友正在访问" << building->m_BedRoom << endl;
}
//友元声明后可以访问类外对象中的私有属性
void goodGay::visitOut(Building* b)
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit();
}
void test02()
{
goodGay gg;
Building b;
gg.visitOut(&b);
}
int main() {
test01();
test02();
system("pause");
return 0;
}
3）成员函数
#include<iostream>
using namespace std;
class Building;
class goodGay
{
public:
goodGay();
void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
void visitOut(Building* b);
void visit2();
private:
Building* building;
};
class Building
{
//告诉编译器 goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
friend void goodGay::visit();
friend void goodGay::visitOut(Building* b);
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
building = new Building;
}
void goodGay::visit()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void goodGay::visitOut(Building* b)
{
cout << "好基友正在访问" << b->m_SittingRoom << endl;
cout << "好基友正在访问" << b->m_BedRoom << endl;
}
void goodGay::visit2()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
//不是友元成员函数不可访问
//cout << "好基友正在访问" << building->m_BedRoom << endl;
}
//友元成员函数可以访问类内类对象的私有属性
void test01()
{
goodGay gg;
gg.visit();
}
//友元成员函数可以访问类外类对象的私有属性
void test02()
{
goodGay gg;
Building b;
gg.visitOut(&b);
}
int main() {
test01();
test02();
system("pause");
return 0;
}
4.5 运算符重载
对已有的运算符重新定义，赋予另一种功能，以适应不同的数据类型。
汇总：
//1.加号运算符重载
Person operator+(const Person& p)
//2.左移运算符重载
ostream& operator<<(ostream& cout, Person& p)
//3.递增运算符重载
//前置++
className& operator++()
//后置++
className& operator++(int)
//4.赋值运算符重载
className& operator=(className &p)
//5.关系运算符重载
bool operator==(className &p)
bool operator!=(className &p)
//6.函数调用运算符重载
dataType operator()(dataType1 p1,...,dataTypen pn)
1.加号运算符重载
这里可以是成员函数实现，也可以是全局函数，而且可以发生重载，非常灵活。
#include<iostream>
using namespace std;
class Person {
public:
Person() {};
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数实现 + 号运算符重载
Person operator+(const Person& p) { //这里只需要再传入一个参数就行
Person temp;
temp.m_A = this->m_A + p.m_A;
temp.m_B = this->m_B + p.m_B;
return temp;
}
public:
int m_A;
int m_B;
};
//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
//Person temp(0, 0);
//temp.m_A = p1.m_A + p2.m_A;
//temp.m_B = p1.m_B + p2.m_B;
//return temp;
//}
//运算符重载 可以发生函数重载
Person operator+(const Person& p2, int val)
{
Person temp;
temp.m_A = p2.m_A + val;
temp.m_B = p2.m_B + val;
return temp;
}
void test() {
Person p1(10, 10);
Person p2(20, 20);
//成员函数方式
Person p3 = p2 + p1; //相当于 p2.operaor+(p1)
cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
Person p4 = p3 + 10; //相当于 operator+(p3,10)
cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
}
int main() {
test();
system("pause");
return 0;
}
2.左移运算符重载
作用：可以输出自定义数据类型。
注意：一般不用成员函数重载，因为cout不能在左边，会实现成：p << cout；
这里这个函数为什么使用引用参数且返回引用数据类型呢？
答：下面有链式调用，因此如果写成void就不能成功调用。而且我们希望一直返回这个唯一的对象，所以我们一般使用引用来获取这个对象。
#include<iostream>
using namespace std;
class Person {
//全局函数要访问类内的私有属性，需要是类的友元！！！
friend ostream& operator<<(ostream& out, Person& p);
public:
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数 实现不了 p << cout 不是我们想要的效果
//void operator<<(Person& p){
//}
private:
int m_A;
int m_B;
};
//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
out << "a:" << p.m_A << " b:" << p.m_B;
return out;
}
void test() {
Person p1(10, 20);
cout << p1 << "hello world" << endl; //链式编程
}
int main() {
test();
system("pause");
return 0;
}
3.递增运算符重载
作用：实现自己的整型数据。
注意：这里的后置不能返回引用，因为返回的是一个临时数据！！！
#include<iostream>
using namespace std;
class MyInteger {
friend ostream& operator<<(ostream& out, MyInteger myint);
public:
MyInteger() {
m_Num = 0;
}
//前置++
MyInteger& operator++() {
//先++
m_Num++;
//再返回
return *this;
}
//后置++
MyInteger operator++(int) {
//先返回
//记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++
MyInteger temp = *this;
m_Num++;
return temp;
}
private:
int m_Num;
};
ostream & operator<<(ostream & out, MyInteger myint) {
out << myint.m_Num;
return out;
}
//前置++ 先++ 再返回
void test01() {
MyInteger myInt;
cout << ++myInt << endl;
cout << myInt << endl;
}
//后置++ 先返回 再++
void test02() {
MyInteger myInt;
cout << myInt++ << endl;
cout << myInt << endl;
}
int main() {
test01();
cout<<endl;
test02();
system("pause");
return 0;
}
4.复制运算符重载
C++编译器至少给一个类添加4个函数：
- 默认构造函数
- 默认析构函数
- 默认拷贝构造
- 赋值运算符operator=
注意：如果类中有在堆区开辟的属性，也会出现深浅拷贝的问题。（重载就可以解决这个问题）
#include<iostream>
using namespace std;
class Person
{
public:
Person(int age)
{
//将年龄数据开辟到堆区
m_Age = new int(age);
}
//重载赋值运算符
Person& operator=(Person& p)
{
//首先要判断堆区属性是否已经存在，存在则要先释放掉
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
//编译器提供的代码是浅拷贝
//m_Age = p.m_Age;
//提供深拷贝 解决浅拷贝的问题
m_Age = new int(*p.m_Age);
//返回自身
return *this;
}
~Person()
{
if (m_Age != NULL)
{
delete m_Age;
m_Age = NULL;
}
}
//年龄的指针
int* m_Age;
};
void test01()
{
Person p1(18);
Person p2(20);
Person p3(30);
p1 = p2 = p3; //赋值操作，这里连续赋值需要返回对象本身 从后往前执行p2 = p3,p1 = p2
cout << "p1的年龄为：" << *p1.m_Age << endl;
cout << "p2的年龄为：" << *p2.m_Age << endl;
cout << "p3的年龄为：" << *p3.m_Age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
5.关系运算符重载
作用：让两个自定义类型对象进行对比操作。
#include<iostream>
using namespace std;
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
};
bool operator==(Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return true;
}
else
{
return false;
}
}
bool operator!=(Person& p)
{
if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
{
return false;
}
else
{
return true;
}
}
string m_Name;
int m_Age;
};
void test01()
{
//int a = 0;
//int b = 0;
Person a("孙悟空", 18);
Person b("孙悟空", 18);
if (a == b)
{
cout << "a和b相等" << endl;
}
else
{
cout << "a和b不相等" << endl;
}
if (a.operator!=(b))
{
cout << "a和b不相等" << endl;
}
else
{
cout << "a和b相等" << endl;
}
}
int main() {
test01();
system("pause");
return 0;
}
6.函数调用运算符重载
- 由于重载后使用的方式非常像函数的调用，因此称为仿函数
- 仿函数没有固定写法，非常灵活
#include<iostream>
using namespace std;
class MyPrint
{
public:
void operator()(string text)
{
cout << text << endl;
}
};
void test01()
{
//重载的（）操作符 也称为仿函数
MyPrint myFunc;
myFunc("hello world");
}
class MyAdd
{
public:
int operator()(int v1, int v2)
{
return v1 + v2;
}
};
void test02()
{
MyAdd add;
int ret = add(10, 10);
cout << "ret = " << ret << endl;
//这里创建了一个匿名对象MyAdd（），然后调用了这个仿函数
cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
4.6 继承
继承是面向对象三大特性之一！
也就是说子类有父类的一些特性，我们就可以考虑利用继承的技术减少重复代码。
1.继承的基本语法
class A ：public B（A称为子类或者派生类，B称为父类或基类）
派生类中有两大部分：一类是从基类继承过来的，另一类是自身增加的成员。（共性和特性）
2.继承方式
公共继承、保护继承、私有继承
总结区别：
- 父类的隐私属性哪种继承都无法访问
- 保护继承将其他属性都变成保护属性
- 公有继承将其他属性都变成公有属性
- 私有属性将其他属性都变成私有属性
3.继承中的对象模型
父类中所有非静态的属性都会被继承下来。虽然访问不了。
#include<iostream>
using namespace std;
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};
//公共继承
class Son :public Base
最全的Linux教程，Linux从入门到精通
======================
1. **linux从入门到精通(第2版)**
2. **Linux系统移植**
3. **Linux驱动开发入门与实战**
4. **LINUX 系统移植 第2版**
5. **Linux开源网络全栈详解 从DPDK到OpenFlow**
第一份《Linux从入门到精通》466页
====================
内容简介
====
本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。
**本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。**
> 需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化的资料的朋友，可以点击这里获取！](https://bbs.csdn.net/topics/618542503)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
扫一扫
1478
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
