自下而上的学习面向对象的C++笔记
C++入坑之旅
- 语言学习书籍：primer C++ 中文 第五版
-
- 1.C++基础
-
- 1.1 初学疑问
- 1.2 C到C++的过渡
- 2.引用,类和结构体,string类,
-
- 2.1 函数实参
- 2.2 引用
- 2.3 C++ 对 C 的函数扩展
- 2.4 类和结构体
- 2.5 string 类：
- 课后习题
- 3.7月21日自学 类和对象
-
- 一,构造函数的几点说明
- 二.引用
- 三.析构函数
- 四.对象初始化列表
- 五.编译器对属性和方法的处理机制
- 六.this指针
- 七 友元函数 和 友元类
- 4.初识C++封装
-
- 一.C++中的四种强制类型转换符
- 二.C++封装
- 三.构造函数
- 四..析构函数
- 五.this指针
- 六.初始化列表
- 七 运算符重载
- 一. 类
- 5.重载,简学多态
-
- 二.友元 （少用）
- 三.运算符重载
- 四 .组合 与 继承
- 五.多态
语言学习书籍：primer C++ 中文 第五版
链接说明：语言学习初学者的困惑与其对应的解决方案
1.C++基础
1.1 初学疑问
- 想进游戏公司为什么学习C++语言？
一般开发游戏使用的语言:
2D页游：AS3 JS
3D页游：AS3 C#(Unity)
IOS游戏：Obj-C js/lua(Cocos-2d-x) js/C#(Unity) AS3
安卓游戏：java js/lua(Cocos-2d-x) js/C#(Unity) AS3
在线小游戏：AS3 JS
大型单机游戏/客户端MMORPG：：C++ C#
为什么育碧之类的大公司依然坚定的用C++？
1 工业化好：上中下游都直接首先支持C++，民间普及度也高
2 可以手动控制各种细节，优化的空间非常大。同样的游戏，肯定优先选更流畅逼真的。
3 可以更好的团队开发。
如上是笔者个人提出的问题,但相比而言有自己的作品和扎实的基础才是面试游戏公司的底气。
- C为什么能直接对硬件进行操作?
这个问题是错误的，只有机器语言才能对硬件直接进行操作。
C语言接近硬件是指它可以直接用指针访问硬件地址。
所以，相对来说，C语言在高级语言当中是最贴近物理层面的语言。
- 如何用C语言实现面向对象
C语言实现面向对象学习链接 1
C语言实现面向对象学习链接 2
1.2 C到C++的过渡
- 为什么要引入命名空间的概念
解释命名空间的链接
使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突。
在C++中，变量、函数和类都是大量存在的。
如果没有命名空间，这些变量、函数、类的名称将都存在于全局命名空间中，会导致很多冲突。
目前初学，记住这句话
允许命名空间名字相同，但在此基础上不能允许出现同名变量，否则会报错重复定义。
举例说明：在main.cpp使用其他文件的命名空间
//func1.cpp
#include
namespace A
{
int a = 5;
}
void func1()
{
std::cout << A::a << std::endl;
}
//func2.cpp
#include
namespace B
{
int a = 5;
}
using namespace std;
void func2()
{
cout << B::a << endl;
}
//main.cpp
#include
//有了如下两行声明才可使用
extern void func1();
extern void func2();
using namespace std;
int main()
{
func1();
func2();
}
源文件不能访问其他源文件的命名空间
- 为了避免头文件重定义
#pragma once
//等同于
#ifndef __FUNC1_H
#define __FUNC1_H
#endif
- cin cout 行缓冲 // cerr(出错) clog(日志) 不带缓冲 简单会用就行
cin.ge t与 getchar 有什么不同?
cingetline 可以用来获取字符串
#include
using namespace std;
int main(void)
{
int a,b;
cin >> a >> b;
cout << "a=" << a << ",b=" << b << endl;
char str[100];
char ch = cin.get();
printf("ch=%d",ch);
cout << "ch= " << ch << endl;
cin.getline(str,100);
return 0;
}
- for循环的升级
简述一下就是将变量的声明与初始化限制在for循环内部。
虽然C标准的升级后也允许这样，但C++一开始就如此设定。
for(int i=0;i<2;i++)
{
.....
}
- 关键字的升级
①
register：尽可能将变量保存到cpu内部寄存器中，从而省去了cpu从内存获取的时间，提高了运行效率
注意事项：
1：只能修饰局部变量，不能修饰全局变量和函数；
2：register 修饰的变量不能通过&获取变量的地址：（C++升级：当用&获取变量地址时，该变量不会保存到寄存器中）
3：register 修饰的变量类型一定是cpu所能接受的数据类型！
②
const：C语言中，将const修饰的变量变为只读变量。常应用在修饰函数形参里，保护实参不被修改。
C++升级：const修饰的变量就是常量。const地址必须由const指针保存（const对const ）
记住两点 ： 1 常量 2 .上面升级的整句话
③
typedef：提高代码移植性 提高编码效率 给数据类型重命名；
思考 C语言：使用typedef如何重命名函数指针；
C语言 typedefn int (* P_FuNC)(int,int); C++升级：using P_FUNC2 = int(*)(int ,int );
④
auto：自动变量：强调变量的生命周期
C++升级：auto：类型推导符，目标：现代化标称（提高开发效率） 很强！！！！！！
⑤
malloc 实现原理？free 如何知道要释放多少内存空间？ C++ new delete
malloc是按照字节为单位分配，new按照数据类型为单位分配空间;
malloc是函数，new是运算符;
malloc只分配空间，不初始化，new既可以分配空间又可以初始化。
⑥
一维数组名的作用：保存数据首个元素的地址
二维数组名的作用：保存数据首个一维数组的地址
三维数组名的作用：保存数据首个二维数组的地址
2.引用,类和结构体,string类,
2.1 函数实参
什么时候传值？什么时候传地址？
- 当只使用不修改实参变量的值，传实参变量名；
- 当既使用又修改实参变量的值，传实参变量对应空间的地址；
2.2 引用
参考链接：https://www.jianshu.com/p/d19fc8447eaa
C98标准都是左值引用;
简单判定左值与右值方法: 能取地址便是左值,不能则是右值;
右值引用的符号是 && 左值引用的符号是 &；
1.引用的注意事项：
- ①引用必须在定义的同时初始化变量；
- ②只能绑定到一个变量；
- ③当用const限制一个引用变量时，需要 const对const；
2.引用可以作为形参,解决了传参和传地址；
3.作返回值时函数调用可作为左值；
4.引用是否占用内存空间？
- 从使用角度看是不占内存的；
- 从编译器角度的确给分配了空间，32位 4字节 64位 8字节；
5.面试问题：指针和引用的区别；
- ①不存在空引用（保证不操作空指针），
- ②必须初始化（保证不是野指针），
- ③一个引用永远指向他初始化的那个对象（保证指针值不变）。
也可以查阅链接：https://blog.csdn.net/boy_of_god/article/details/81022316
6.面试问题：为什么会出现引用？
结论：直接的原因是为了支持运算符重载
也可以查阅链接：https://www.cnblogs.com/lfri/p/12695938.html
7.左值引用，右值引用；左值右值如何判断？
- 左值：可赋值可取地址；右值：不是左值就是右值
- 左值引用只能绑定左值；右值引用只能绑定右值。
也可以查阅链接：https://blog.csdn.net/u012198575/article/details/83142419
8：引用：什么时候加const？ 什么时候不加const？
也可以查阅链接：https://blog.csdn.net/sammie123321/article/details/96426851
#include
using namespace std;
//引用可以作形参
void func1(int &a,int &b)
{
int temp = 0;
temp = a;
a = b;
b = temp;
}
//引用作为返回值 函数可以作左值
int & func2(const int &a)
{
int num = 5; //此时会警告，返回一个局部变量，改变如下注释:
//static int num = 5;
return num;
)
int main(void)
{
int a = 5,b = 6;
func1(a,b)
cout << a << "," << b << endl;
func2(a) =10;
cout << a << endl;
int num = 5;
int &l_num = num;
//int &l_num = 5;//测试左值引用绑定左值，报错
//static int &l_num = 5;解决左值错误问题；
int &&r_rnum = 5;//右值引用绑定右值
//int &&r_rnum = num;//测试右值引用绑定左值，失败，报错；
//int &&r_rnum = std::move(num);//右值改成左值 成功
//但这里发生了 对象移动
// 对象移动解决的是对象拷贝的开销问题
return 0;
}
2.3 C++ 对 C 的函数扩展
1.时间换空间，空间换时间
- 时间：运行时间，编译时间；
- 空间：内存空间；
也可以查阅链接：https://blog.csdn.net/cui929434/article/details/98033039
2.用编译时间换内存空间？（宏函数）
#define MAX(a,b) ((a) > (b)) ? (a) : (b)//傻瓜式替换，预处理阶段
//如上增加了编译时间
//如下增加了内存时间
int max_num(int a,int b)
{
return a > b ? a : b;
}
3.用内存时间换内存空间？
-
C语言：
(inline(只能修饰函数C99)内联函数：将函数体的代码段内嵌到函数调用的地方）
inline：将代码内嵌到函数调用的地方，省去了函数调用返回的过程，提高了程序运行效率；
C语言下只要声明为inline(内敛)，一定会一内联的方式进行处理 -
C++升级：
（编译器会判断：循环，静态，递归，异常处理；包括这些都不会实现）
什么时候使用inline？ 功能简单且代码短小，但频繁调用！
// 5 行代码以内吧，一定相信存在必定有用！！！！ -
使用注意事项：
调用inline内联函数之前必须声明或者定义该函数
void func(); //不声明直接使用func()会报错，必须提前声明
inline void func(){}
内联函数作用：
- ① 内联函数在编译的时候将不进行函数调用;
- ② 编译器将内联函数的代码粘贴在调用（形式上调用）处，可以提高效率；
inline max_num(int a,int b)
{
return a > b ? a : b;
}
int main()
{
max_num(5,3);
max_num(3,4);
}
4.默认参数：
- 函数默认参数：函数定义时给形参指定值
- 默认参数规则：当前参数的右边参数必须有默认参数
- 函数占位参数：预留参数接口，函数调用时必须指定参数；
5.重载
函数重载条件？
- ① 函数名可以相同，函数形参不同；
- ② 形参个数相同，但是类型不同；
- ③ 形参个数不同；
注意事项：注意默认参数对重载条件的影响；
void add(int a,int b = 5){}//报错，出现二义性；
void add(int a){}
2.4 类和结构体
1.结构 的升级：
- C语言：
内部只能通过函数指针去访问外部函数； - C++升级：
①定义变量(结构体名+变量名)
②结构 可以保存函数
③结构 可以继承
④结构 可以多态
⑤结构 可以封装(权限修饰符：public，pravite，protect 控制访问权限)
结构 默认访问权限是public；
类 默认访问权限是private；
//private 不能通过变量外界访问，但可以在内部函数中访问
2.class vs struct
C++新的数据类型：class；基本上完全等同于结构体；
-
语法上唯一一个区别：class默认权限是private，struct默认权限是public；
-
叫法区别：
①class类，struct结构体；
②class定义的变量称之为对象，struct称之为变量；
③class里保存得变量称之为属性或者成员变量；保存的函数称之为方法；
#include
using namespace std;
struct Node
{
int num;
public:
void test()
{
cout << "func test" << endl;
}
};
struct Nodes : public Node
{
void test1()
{
cout << "func test1" << endl;
}
};
int main()
{
Node p;
p.test();
Nodes ps;
ps.test();
return 0;
}
#include
using namespace std;
class Student
{
public:
int mNum;
char mName[20];
int mage;
/*void eat()//类内实现，有可能被内联，消耗内存
{
cout << "eat" << endl;
)
*/
void eat();//外部实现需要声明
};
void Student::eat()
{
cout << "eat" << endl;
}
int main(void)
{
return 0;
}
举一个将类写进头文件的例子：
func.h
#pragma once//防止头文件重复包含
#include
using namespace std;
class Student
{
public:
void eat()
{
cout << "eat" << endl;
}
};
func.c
#include
#include "func4.h"
using namespace std;
int main(void)
{
Student p;
p.eat();
return 0;
}
2.5 string 类：
1.介绍
std提供的标准字符串处理的类，class string；
特点：可变长(动态分配)(所以不用关心长度)
#include
#include
using namespace std;
int main(void)
{
//string的定义
string s = "hello world";//s叫做对象
string t = "hahhahaha";
string s2 = s + t;//strcat
string s3("hello world");// 构造函数初始化的方式
string s4(10,'a');
cout << s3 << endl;
cout << s2 << endl;
cout << s4 << endl;
return 0;
}
2.string 的属性
- ①：size()： string的大小
- ②：empty(): 判断是否为空； bool
- ③：capacity()：返回的是string当前的容量
- ④：resize():重置大小
#include
#include
using namespace std;
int main(void)
{
string s("helloworld");
// 两种方法无区别测长度，但建议使用size()；
cout << "size1=" << s.size() << endl;//no '\0'
cout << "size1=" << s.length() << endl;//no '\0'
return 0;
}
#include
#include
using namespace std;
int main(void)
{
string s("helloworld");
cout << "size1=" << s.size() << endl;//no '\0' //jianyi yong
cout << "size1=" << s.length() << endl;//no '\0'
cout << "is empty:" << s.empty() << endl;
//判断是否为空，empty()
cout << "capacity:" << s.capacity() << endl;
s.resize(100);
//resize重置大小，但未修改字符串
cout << "capacity:" << s.capacity() << endl;
s.resize(100,'a'); //memset
//重置大小并用 a 填充
cout << "capacity:" << s.capacity() << endl;
cout << s << endl;
string s1;
string s2 = "";
cout << "is empty:" << s1.empty() << endl;
cout << "is empty:" << s2.empty() << endl;
return 0;
}
3. string 输入输出
#include
#include
using namespace std;
int main(void)
{
string s;
//cin.getline(s,100);//报错，实参string 形参char，类型不兼容
//cin >> s; // 获取单词用这种
getline(cin,s);//获取句子用这种
cout << s << endl;
string src;
strcpy(src,s.c_str());
cout << s << endl;
return 0;
}
4.string 的遍历
#include
#include
using namespace std;
int main(void)
{
string s("hello world");
for(int i = 0;i 5.迭代器iterator：指针（内部指针）
三种：正向，反向：const
#include
#include
using namespace std;
int main(void)
{
string s("hello world");
//string :: iterator begin_it = s.begin();
//string :: iterator end_it = s.end();
for(auto it = s.begin();it != s.end();it++)
{
cout << *it << endl;
}
//string::const_iterator it = s.cbegin();
for(auto it = s.cbegin();it!=s.cend();it++)
{
cout << *it << endl;
}
//string::reverse_iterator it = s.rbegin();
for(auto it = s.rbegin();it != s.rend();it++)
{
cout << *it << endl;
}
return 0;
}
自学网站：https://en.cppreference.com/w/
6.string 赋值
7.string 连接
8.string 比较
9.string 类的子串（比较重要，可以借助手册网站）
10.string 交换
11.下面是最重要最常用的
查找：最好去官网看源码：
#include
#include
using namespace std;
int main(void)
{
string const s = "this is a string";
std::string::size_type n;
n = s.find('w');
cout << n << endl;
if(n == string::npos)
{
cout << "not found" << endl;
}
return 0;
}
查找总结：
str.find_first_of(查找目标字符串中任意一个字符在str里第一次出现的位置)
str.find_last_of(查找目标字符串中任意一个字符在str里最后一次出现的位置)
str.find_first_not_of(s)(str中第一个不是目标字符串任意一个字符的位置)
str.find_last_not_of(s)(str中最后一个不是目标字符串中任意一个字符的位置)
12.替换 自学
13.删除 迭代器
#include
#include
using namespace std;
int main(void)
{
string s = "abdcd";
//s.erase(1;
//s.erase(1,1);
auto it = s.erase(s.begin()+1);
cout << *it << endl;
//cout << s << endl;
return 0;
}
14.插入 自学
用迭代器！！！
15.容器, 删除
#include
#include
#include
using namespace std;
int main(void)
{
vector v1={1,2,3,4,5};
vector v2;
vector v3;
v3.push_back("hello");
//v3.push_back("world");
//bianli
/*for(auto it = v1.begin();it!=v1.end();it++)
{
cout << *it << endl;
}
*/
//shanchu
v1.erase(v1.begin()+1);
//cout << v3 << endl;
for(auto it = v1.begin();it!=v1.end();it++)
{
cout << *it << endl;
}
return 0;
}
课后习题
字符串I am from shanghai 分别用 C/C++ 实现逆序打印 输出：shanghai from am i；
3.7月21日自学 类和对象
基于《面向对象的嵌入式软件开发》一书。
一,构造函数的几点说明
① 构造函数的名称必须和类的名称相同
② 构造函数不能有返回值，函数体中不能有return语句
③ 构造函数在定义对象时会自动执行，不需手动调用
注意事项：
1.构造函数的调用是强制性的，不调用是错误的;
2.创建对象时只有一个构造函数会被调用,而且构造函数只会在对象刚被创建时被调用。
3.如果用户没有定义构造函数，那么编译器会自动生成一个默认的无参构造函数，
只是这个构造函数的函数体是空的，也不执行任何操作；
4.如果没有定义的拷贝构造函数，编译器也会自动生成一个默认的拷贝构造函数，进行简单数据的赋值。
5.一个类必须有构造函数，要么用户自己定义，要么编译器自动生成。
一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器都不再自动生成。
二.引用
① 为了避免进行数据的拷贝，最好使用引用;
② 为了避免实参数据被修改，最好使用常引用;
三.析构函数
① 析构函数没有参数，不能被重载
② 一个类只能有一个析构函数,要么用户自己定义，要么编译器自动生成一个默认的析构函数
③ 析构函数在对象被销毁时调用，而对象的销毁时机与它所在的内存区域有关；
四.对象初始化列表
注意事项
① 初始化列表要优先于当前对象的构造函数先执行；
② 子对象的初始化顺序和其在初始化列表的排列顺序无关，但和在类中的声明顺序有关，先声明的先初始化
③ 析构函数的调用顺序与构造函数相反；
④ 参数初始化表还有一个很重要的作用，那就是初始化const成员变量，
初始化const成员变量的唯一方法就是使用参数初始化表。
对于上述不足的点补充：
问：对象初始化列表什么时候使用？
https://blog.csdn.net/wy1550365215/article/details/77930637
五.编译器对属性和方法的处理机制
问：一个对象所占内存大小如何计算呢？如下举例说明：
#include
using namespace std;
class Test
{
public:
Test(int a,int b)
{
m_a = a;
m_b = b;
}
void print()
{
cout << "a=" << m_a << ",b=" << m_b << endl;
}
static void printS()
{
cout << "c=" << m_c << endl;
}
private:
int m_a;
int m_b;
static int m_c;
};
int main(void)
{
printf("size=%d\n",sizeof(Test));
Test t1(1,2),t2(3,4);
t1.print();
t2.print();
return 0;
}
测试结果：
size=8 表明是两个整型字节数大小。
其实C++类对象中的成员变量和成员函数是分开存储的;
① 普通成员变量：存储在对象中，与struct变量具有相同的内存布局和字节对齐方式。
② 静态成员变量：存储在全局数据区中。
③ 成员函数：存储在代码段中。
计算大小时不是很好理解，比如：
问：很多对象共用一块代码，代码是如何区分具体的对象？
这里涉及编译器对类中成员函数的处理。类在C++内部是用结构体来实现的?
#include
using namespace std;
struct Test
{
int m_a;
int m_b;
};
static int m_c = 10;
void Test_init(Test* const p,int a,int b)
{
p->m_a = a;
p->m_b = b;
}
void Test_print(Test* const p)
{
cout << "a=" << p->m_a << ",b=" << p->m_b << endl;
}
void Test_printS()
{
cout << "c=" << m_c << endl;
}
int main(void)
{
Test t1;
Test_init(&t1,1,2);
Test t2;
Test_init(&t2,3,4);
Test_print(&t1);
Test_print(&t2);
return 0;
}
如上代码模拟编译器的内部处理，以帮助更好理解 类，并不是编译器内部的真正实现。
由以上的转换,可以看出：
① C++类对象中的成员变量和成员函数是分开存储的，C语言中的内存四区模型仍然有效。
② C++中类的普通成员函数都隐式地包含一个指向当前对象的常指针，
在上面代码的转换中就是指针p，通过这个常指针可以知道当前操作的是哪一个对象。
③ 静态成员函数，成员变量属于类
静态成员函数与普通成员函数的区别：
① 静态成员函数不包含指向具体对象的指针。
② 普通成员函数包含一个指向具体对象的指针。
六.this指针
类的普通成员函数都有一个指向当前对象的常指针，C++的关键字this就是那个指针
功能：代表当前操作对象。
七 友元函数 和 友元类
1.友元函数:当前类的外部定义,不属于当前类的函数也可以在类中声明，但要在前面加关键字friend,这样就构成了友元函数。友元函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数。友元函数可以访问当前类中的所有成员，包括public，proteted，private等属性的成员；
如何将非成员函数声明为友元函数呢？
#include
using namespace std;
class Student
{
friend void show(Student *pstu);
public:
Student(char *name,int age,float score):m_name(name),m_age(age),m_score(score)
{
}
private:
char *m_name;
int m_age;
float m_score;
};
void show(Student *pstu)
{
cout << pstu->m_name << "year is " << pstu->m_age << ",score is " << pstu->m_score << endl;
}
int main()
{
Student stu("ming",15,90,6);
show(&stu);
Student *pstu = new Student("li",16,80.5);
show(pstu);
return 0;
}
而友元函数不能 直接 访问类的成员，必须借助对象；
2.友元类
有缘类中的所有成员函数都是另外一个类的友元函数。
3.友元函数的几点注意事项：
① 友元函数的声明与位置，public，private等都无关，可以在类的内部任意位置声明友元函数。
② 友元函数不是类的内部函数。
③ 友元的关系是单向的而不是双向的，如果声明了类B是类A的友元类，
不等于类A是类B的友元类，类A中的成员函数不能访问类B中的private成员。
④ 友元的关系不能传递，如果类B是类A的友元类,类C是类B的友元类,不等于类C是类A的友元类。
⑤ 友元函数会破坏类的封装性，不是迫不得已，尽量少用友元函数。
4.初识C++封装
一.C++中的四种强制类型转换符
四种目前先学两种,static_cast，const_cast；其他了解看如下链接https://www.cnblogs.com/linuxAndMcu/p/10387829.html#_label0
① static_case(静态转换)
② const_cast(常量转换)
③ reinterpret_cast(不相关类型的转换)
④ dynamic_cast(动态转换)
- static_case(静态转换)
使用场景：
- 基本数据类型之间转换,但安全性问题由程序员自己把握;
- 在有类型指针 与 void* 之间转换 (目前是遇到这种情况的时候强转)
- 用于 类 层次结构中 基类 和 派生类 之间 指针 或 引用 的转换
上行转换(子类--->父类) 安全;
下行转换(父类--->字类) 不安全; //由于没有动态类型检查，所以是不安全的;
问:什么是动态类型检查 ？C++如何实现 ? 使用场景 ?
出现了很多暂时看不懂的名词,先放一放。
https://blog.csdn.net/yuanzhangmei1/article/details/11962887
问:静态类型和动态类型有什么区别?
发生在不同语言的类型比较上,和现阶段学习的知识不符合,但可以了解一下
https://www.jianshu.com/p/bc492fcbf18f
② 使用特点:
- 主要执行非多态的转换操作，用于代替C中通常的转换操作。
- 隐式转换都建议使用 static_cast 进行标明和替换。
- 不能使用 static_cast 在有类型指针内转换。翻译：指针两者之一必须是 void* 才能转换
③ 编程实例：
#include
using namespace std;
class CBase //基类(父类)
{
};
class CDerived : public CBase //派生类(子类)
{
};
int main()
{
//1.使用static_cast在基本数据类型之间转换
float fval = 10.12;
int ival = static_cast(fval); // float-->int
cout << ival << endl; //out:10;
//2.使用static_cast在有类型指针与void* 之间转换
int* intp = &ival;
void* voidp = static_cast(intp); // int*--->void*
//cout << *voidp << endl; //error,voidp的大小未知
long* longp = static_cast(voidp);
cout << *longp << endl; // out:10
//3.用于类层次结构中基类和派生类之间指针或引用的转换
//上行转换(派生类--->基类)是安全的
CDerived* tCDerived1 = nullptr;
CBase* tCBase1 = static_cast(tCDerived1);
//下行转换(基类--->派生类)由于没有动态类型检查，所以是不安全的
CBase* tCBase2 = nullptr;
CDerived* tCDerived2 = static_cast(tCBase2);//不会报错 但是不安全
// 不能使用static_cast在有类型指针内转换
float* floatp = &fval; //10.12的addr
//int *intp1 = static_cast(floatp);
//error,不能使用static_cast在有类型指针内转换
cout << *floatp << endl; //out : 10.12
return 0;
}
2.const_cast:(常量转换)
- 使用场景
常量指针（或引用）与非常量指针（或引用）之间的转换。 - 使用特点：
cosnt_cast 是四种类型转换符中唯一可以对常量进行操作的转换符。
去除常量性是一个危险的动作，尽量避免使用。 - 实例
#include
using namespace std;
int main()
{
int value = 100;
const int* cpi = &value; // 定义一个常量指针
//*cpi = 200; // 不能通过常量指针修改值 常量指针可以修改指针
cout << *cpi << endl;
// 1. 将常量指针转换为非常量指针,然后可以修改常量指针指向变量的值
int* pi = const_cast(cpi); //将cpi的类型从 const int* 强转成 int*
// const 对 const
*pi = 200;
cout << *pi << endl;
// 2. 将非常量指针转换为常量指针
const int* cpi2 = const_cast(pi); // *cpi2 = 300; //已经是常量指针
const int value1 = 500;
const int& c_value1 = value1; // 定义一个常量引用 //左值引用绑定左值
//如果能取地址 就是左值； 不能取地址就是右值；
// 3. 将常量引用转换为非常量引用
int& r_value1 = const_cast(c_value1);
// 4. 将非常量引用转换为常量引用
const int& c_value2 = const_cast(r_value1);
}
二.C++封装
问：如何体现封装解决代码的维护性 ?
简答：保证代码的独立性,从而提高代码的维护性
问：独立性的好处？ 封装如何保证独立？
简答：通过类的权限修饰符限制访问权限。pubulic,private,protect
三.构造函数
特点：
①.自动调用（实例对象时,自动调用构造函数）
② 构造函数的函数名与类名一致；
③ 构造函数没有返回值
④ 构造函数可以重载；
⑤ 当类中无任何构造函数时，系统会默认生成一个无参的构造函数
但凡有一个构造函数，编译器都将不再生成构造函数。
构造函数的种类：
①- 无参构造函数；
②- 有参构造函数；
③- 拷贝构造函数；
形参是该类型的对象引用：若类里无自定义拷贝构造函数，系统会默认生成拷贝构造函数。
深拷贝和浅拷贝(默认生成 的拷贝都是浅拷贝)（多个成员指向了同一块空间）
（多个成员指向不同的空间）（只有类里有指针才会涉及到深拷贝和浅拷贝）
④- 移动拷贝构造函数；
解决对象拷贝的开销问题；尤其是临时对象；
对象移动：将该对象移动到目标对象的空间（获取目标对象的空间使用权）
匿名对象：https://www.cnblogs.com/cthon/p/9173472.html
//移动拷贝构造函数
Test(Test &&other) noexcept
{
cout << "move copy Test" << endl;
this->m_ptr = other.m_ptr;
other.m_ptr = nullptr;
}
⑤- 类型转换构造函数；
explicit：防止编译器发生隐式转换
补充：C++11 引入的两个关键字，delete default
例如
class A
{
public：
//A()=delete;//告诉编译器不生成默认无参构造函数
//A()=default;//告诉编译器自动生成无参构造函数
};
如何写好构造函数 ???
https://blog.csdn.net/farsight2009/article/details/4601396
四…析构函数
特点：
- 无返回值
- 规定函数名：~类名
- 无参
- 不能重载
- 当对象离开所在作用域释放空间时先调用析构函数。
- 一个类只有一个
五.this指针
1.thisi指针：每实例化一个对象都有一个指向该对象的指针(this)
2.对象模型：每个对象都有自己独立的属性（成员变量）空间，共享代码空间(方法，函数)；
3.this指针的作用：区别同一个类定义的不同实例
六.初始化列表
1.定义并初始化(先于构造函数)，初始化效率高于构造函数初始化(不用发生函数调用)
2.什么情况下会使用初始化列表？https://blog.csdn.net/wy1550365215/article/details/77930637
- 非静态常量数据成员的初始化
- 引用成员的初始化
- 初始化没有默认构造函数的成员对象
- 基类数据成员的初始化
- 当构造函数的参数名字与数据成员的名字相同时
- 性能原因
自己写二代初始化列表例子: 因为学的时候函数末尾忘记加分号 一直报错没发现。
然后写了构造函数,发现根本不会调用构造函数。
#include
using namespace std;
class A
{
public:
int m_a, m_b;
A(int a, int b) :m_a(a), m_b(b) {};
void print()
{
cout << m_a << "," << m_b << endl;
}
};
int main(void)
{
A a(5, 6);
a.print(); //输出5，6 正确;
return 0;
}
引用成员的初始化示例：
//int& r_num 课上提问答错了,必须记住！
class B
{
public:
int B_num;
B b;
//int& r_num;//不注销报错,原因是左值引用只能绑定左值
B () : B_num(0)，b(5)//，r_num(0)
{};
B(int num)
{
this->B_num = num;
}
};
七 运算符重载
//运算符重载函数：=
Test &operator=(const Test &other)
{
cout << "operator =" << endl;
int len = strlen(other.m_ptr);
this->m_ptr = new char[len + 1];
strcpy(m_ptr, other.m_ptr);
return *this;
}
一. 类
在构建一个类的时候,有些成员函数必定会写：
构造函数，析构函数，运算符重载,set/get方法,普通成员函数,静态成员函数
所以可能用会用到关键字：static，const，mutable，
其中关键字 static 的作用：
用来声明静态变量。a.修饰局部变量——>会提升局部变量的生存周期
b.修饰全局变量——>作用域被限制——>被限制到当前的原文件中
c.修饰函数——>作用域被限制——>被限制到当前的原文件中
1.关键字 static
①.静态成员：属于类，不属于类的对象(不存在对象的空间中，但被所有对象共享)
注意事项：
不能在构造函数中初始化，只能在类外初始化
权限修饰符会影响静态成员
class Test
{
public:
static int m_num;
int m_count;
private:
//static int m_connt //错误，权限修饰符会影响静态成员
};
int Test::m_num=5; //类外初始化
int main()
{
Test t1;
cout << sizeof(t1) <②.静态成员函数：属于类,不属于对象(被所有对象共享,没有this指针意味着不能访问非静态成员)
class Test
{
public:
static int m_num;
int m_count;
static void print()
{
//cout << m_count << endl;//错误，访问非静态常量
cout << m_num << nedl;//正确，只能访问静态成员
}
};
//普通成员方法的函数名不是函数的入口地址，无法作为参数传递；
//static修饰的方法的函数名就是函数的入口地址，可以作为参数传递；
2.问题：
c/c++中static关键字的作用 ？
C语言:
https://www.cnblogs.com/ustc-anmin/p/11239257.html
C++升级后：
https://www.cnblogs.com/songdanzju/p/7422380.html
5.重载,简学多态
二.友元 （少用）
友元的作用：提高程序运行效率(让类的非公有函数可以直接访问类的非公有成员，
省去了函数调用的过程)
友元的缺点：破坏了C++ 的封装性！
友元的种类：友元函数，友元类，友元成员函数
1 友元函数：
意义：是指某些虽然不是类成员却能够访问类的所有成员的函数。
形式： friend 类型名 友元函数名（形参表）;
注意：
① 函数必须在类中说明,说明可以出现在类的任何地方，包括在 private 和 public 部分；
② 类外定义。
2 友元类：
友元类的所有成员函数都是另一个类的友元函数，
都可以访问另一个类中的隐藏信息.（包括私有成员和保护成员）
注意事项：
(1) 友元关系不能被继承。
(2) 友元关系是单向的，不具有交换性。要看在类中是否有相应的声明。
(3) 友元关系不具有传递性。同样要看类中是否有相应的申明。
1,2 写个简单例子
/* 形参很烦
友元函数的使用
因为友元函数没有this指针，则参数要有三种情况：
1.要访问非static成员时，需要对象做参数；
2.要访问static成员或全局变量时，则不需要对象做参数；
3.如果做参数的对象是全局对象，则不需要对象做参数.
4.可以直接调用友元函数，不需要通过对象或指针
*/
class One
{
public:
//友元类的声明，表示 two索取one的内容
friend class two;
//该函数是友元函数的声明
friend void print(int num,One& a);
private:
int m_num;
};
//友元函数能访问到类中所有成员
void print(int num, One& a)
{
a.m_num = num;
cout << a.m_num << endl;
}
class Two
{
public:
};
int main(void)
{
One a;
print(1, a);
return 0;
}
3.友元成员函数
// 使类B中的成员函数成为类A的友元函数，
// 这样类B的该成员函数就可以访问类A的所有成员了。
// 一般的讲，必须先定义包含成员函数的类，才能将成员函数设为友元。
// 另一方面，不必预先声明类和非成员函数来将它们设为友元。
class A;
//当用到友元成员函数时，需注意友元声明与友元定义之间的互相依赖。这是类A的声明
class B
{
public:
void set_show(int x, A& a); //该函数是类A的友元函数
};
class A
{
public:
friend void B::set_show(int x, A& a); //该函数是友元成员函数的声明
private:
int data;
void show() { cout << data << endl; }
};
void B::set_show(int x, A& a)
//只有在定义类A后才能定义该函数，毕竟，它被设为友元是为了访问类A的成员
{
a.data = x;
cout << a.data << endl;
}
int main(void)
{
class A a;
class B b;
b.set_show(1, a);
return 0;
}
三.运算符重载
这几个运算符不能进行重载 “::”, "?: “, “.”, " .*” , “sizeof”
简单实现运算符重载例子：
#include
#include
#include
using namespace std;
using p_func = void(*)(void);
class Test
{
public:
int m_num;
string m_s;
char *m_ptr;
Test()
{
m_ptr = new char[100];
}
Test(int num, string s, char *ptr) : m_num(num), m_s(s)
{
int len = strlen(ptr);
this->m_ptr = new char[len + 1];
strcpy(m_ptr, ptr);
}
~Test()
{
delete[] m_ptr;
}
static void print()
{
cout << "hello world" << endl;
}
Test &operator=(const Test &other)
{
if (this != &other)
{
this->m_num = other.m_num;
this->m_s = other.m_s;
int len = strlen(other.m_ptr);
this->m_ptr = new char[len + 1];
strcpy(m_ptr, other.m_ptr);
}
return *this;
}
bool operator>(const Test &t)
{
return this->m_num > t.m_num;
}
bool operator<(const Test &t)
{
return this->m_num < t.m_num;
}
friend ostream &operator<<(ostream &out, const Test &t)
{
out << "num = " << t.m_num << endl;
out << "s = " << t.m_s << endl;
out << "ptr = " << t.m_ptr;
return out;
}
friend istream &operator>>(istream &in, Test &t)
{
in >> t.m_num;
in >> t.m_s;
in >> t.m_ptr;
return in;
}
operator int()
{
return this->m_num;
}
operator char*()
{
return this->m_ptr;
}
operator p_func()
{
return print;
}
//i++ ,++i; //实现
//()函数运算符 -- 函数对象
};
int main()
{
string s = "hello world";
Test t1(1, s, "zhangsan");
Test t2;
t2.operator=(t1);
//cout << s << "hello" << endl;
//cout.operator<<(cout,t2);
//operator<<(cout,t2);
cout << t2 << "hello" << endl;
Test t3;
cin >> t3;
cout << t3 << endl;
if(t2 > t3)
{
cout << "t2 > t3" << endl;
}
int num = static_cast(t3);
int num2 = static_cast(t2);
cout << num << endl;
cout << num2 << endl;
string s2 = static_cast(t3);
char *ptr = static_cast(t2);
//cout << s2 << endl;
cout << ptr << endl;
p_func f = static_cast(t2);
f();
for(int i = 0; i < 5 ; ++i)
{
}
return 0;
}
四 .组合 与 继承
1.组合定义：在新类里面创建原有类的对象，重复利用已有类的功能。(has-a关系)
2.继承定义：可以使用现有类的功能，
并且在无需重复编写原有类的情况下对原有类进行功能上的扩展。(is-a关系)
简单写一个实例表示：
class A
{
public:
private:
};
class B
{
public:
A a;//B里有A的对象,就是组合
private:
};
class C : public B //继承
{
public:
};
int main(void)
{
return 0;
}
3.问题：继承规则
有public、private、protected三种
（它们直接影响到派生类的成员、及其对象对基类成员访问的规则）
① public（公有继承）：
继承时保持基类中各成员属性不变，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象只能访问基类中的public成员。
② private（私有继承）：
继承时基类中各成员属性均变为private，并且基类中private成员被隐藏。
派生类的成员也只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象不能访问基类中的任何的成员。
③ protected（保护性继承）：
继承时基类中各成员属性均变为protected，并且基类中private成员被隐藏。
派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；
派生类的对象不能访问基类中的任何的成员。
父类私有 绝对不可被继承的子类所使用
4.什么时候用组合,什么时候用定义
目前简单用 has-a 包含关系 判断用组合，is-a 属于关系 判断用继承
https://blog.csdn.net/niuyisheng/article/details/9734921
五.多态
心得:多态性还有动态绑定很好用，:多态性是指不同类的对象对同一消息的不同回应，
我脑海里出现了一个场景:
我妈喊吃饭的时候，我爸可以慢悠悠下楼，我却是不可以的（慢了会被我妈念叨）
要想在程序中实现多态（动态绑定）得几个条件:
1.弄明白类继承图
2.避免例子中Base d=b这种错误，要通过父类的指针或者引用调用虚函数
3.指针的指向对象不能弄乱。
父类和子类之间互相赋值的类型兼容原则，支持向上类型转换。
作用：不会发生类型变化（只有继承的情况下，且不支持向下类型转换）
意义：实现多态的前提条件
利用了虚函数,暂时不太懂,不过没事
注意事项：类外实现不再加virtual;如果担心函数遮蔽,就在虚函数名字后面添加 override ;
https://www.cnblogs.com/alinh/p/9636352.html
#include
using namespace std;
class A
{
public:
int m_a;
A(int a):m_a(a) //初始化列表
{
cout << "A()" << endl;
}
virtual void print() //虚函数
{
cout << "A" << endl;
}
virtual ~A()//析构函数
{
cout << "~A()" << endl;
}
};
class B : public A
{
public:
int m_b;
B(int b) : m_b(b),A(5)
{
cout << "B" << endl;
}
virtual void print() override
{
cout << "B" << endl;
}
~B()
{
cout << "~B()"<< endl;
}
};
class C : public A
{
public:
int m_c;
C(int c) : m_c(c),A(5) {}//初始化列表
virtual void print()
{
cout << "C" << endl;
}
~C(){}
};
class D : public A
{
public:
int m_d;
D(int d) : m_d(d),A(5){}
virtual void print()
{
cout << "D" << endl;
}
~D(){}
};
//同一接口，传递不同的实例，执行不同操作！
// 如果没有虚拟函数,没有函数遮蔽,测试函数要写的如下所示,很麻烦
// void test(A a)
// {
// a.print();
// }
// void test(B b)
// {
// b.print();
// }
// void test(C c)
// {
// c.print();
// }
void test(A &pa)
{
pa.print();
}
//同一接口，传递不同的实例，执行不同操作！
//多态的条件：1、继承 2、发生函数遮蔽 3、虚函数
//多态的发生时机：父类的指针或者是引用指向子对象；
//多态的意义：可以在任意地方用子类替换父类；
//多态的作用：提高代码的扩展性；
(添加新的功能时，不修改原来的代码，只添加新的代码（开闭原则）)
//多态实现的情况下，父类的析构函数必须是虚析构函数？
如果不是，就不能正常释放子对象的空间？
int main()
{
//父类和子类之间互相赋值的类型兼容原则：支持向上类型转换
// A a(5);
// B b(10);
// C c(15);
// D d(20);
// test(a);
// test(b);
// test(c);
// test(d);
// A *pa = &a;
// B *pb = &b;
// C *pc = &c;
// a = static_cast(b);
//向上转型:不会发生类型变化；(只有继承) 意义：实现多态的前提条件
// a.print();
// a = c;
// a.print();
// //同一接口，传递不同的实例，执行不同操作！
// pa = pb;
// pa->print();
// pa = pc;
// pa->print();
// pb = pa;
//b = static_cast(a);//不支持向下类型转换（只有继承）
//B b(10);
A *pa = new B(10);
delete pa;
return 0;
}
PS:后续笔记会一直在本文补充。