黑马程序员C++核心编程笔记
黑马程序员C++核心编程笔记
[toc]
C++核心编程
0.基础知识
结构体：
- 结构体属于用户自定义的类型，允许用户存储不同的数据
C语言和C++结构体的区别
- 在C语言中，可以定义结构体类型，将多个相关的变量包装成为一个整体使用。在结构体中的变量，可以是相同、部分相同，或完全不同的数据类型。在C语言中，结构体不能包含函数。在面向对象的程序设计中，对象具有状态（属性）和行为，状态保存在成员变量中，行为通过成员方法（函数）来实现。C语言中的结构体只能描述一个对象的状态，不能描述一个对象的行为。在C++中，考虑到C语言到C++语言过渡的连续性，对结构体进行了扩展，C++的结构体可以包含函数，这样，C++的结构体也具有类的功能，与class不同的是，结构体包含的函数默认为public，而不是private
1. 内存分区模型
c++在执行时，将内存大方向划分为4个区域
● 代码区：存放函数体的二进制代码，由操作系统进行管理。
- 代码区是共享和只读的
● 全局区：存放全局变量和静态变量以及常量。
- 全局区还包含了常量区：字符串常量和const修饰的全局常量也存放在此
- 该区域的数据在程序结束后由操作系统释放
● 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等。局部常量也是存放在栈区的
● 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。
内存四区的意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。
1.1 程序运行前
在程序编译以后，生成了exe可执行程序，未执行程序前分为两个区域。
代码区：
存放CPU执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。
代码区是只读的，为了防止程序意外的修改它的指令，造成损失。
全局区：
全局变量和静态变量存放于此。
全局区还包含了常量区，字符串常量和其他常量存放于此。
该区域的数据在程序结束后由操作系统释放。
（在函数中的变量都是局部变量。全局变量就是写在函数外的。）
总结：
● C++在程序运行前分为全局区和代码区。
● 代码区的特点是共享和只读
● 全局区中存放全局变量，静态变量，常量
● 常量区中存放const修饰的全局常量和字符串常量
1.2 程序运行后
栈区：
由编译器自动分配释放，存放函数的参数值，局部变量等。
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。
#include <iostream>
using namespace std;
//栈区数据注意事项：不要返回局部变量的地址
//栈区的数据由编译器管理开发的释放
int *func() //形参数据也会放在栈区
{
int a = 10; //局部变量：存放在栈区，栈区的数据在函数执行完后自动释放
return &a; //返回局部变量的地址
}
int main()
{
//接受func函数的返回值
int *p = func();
cout << *p << endl; //第一次可以打印正确的数字，是因为编译器做了保留
cout << *p << endl; //没有保留
}
堆区：
由程序员分配释放，若程序员不释放，程序结束时由操作系统释放。
#include<iostream>
using namespace std;
int *func()
{
//利用new关键字 将数据开辟到堆区
//new int(188)返回的是一个地址，所有用指针去接受地址
//指针本质上也是局部变量，放在栈上，指针保存的数据是放在堆区
int *p=new int(188); //小括号里面就是堆区开辟地址初始值。
return p;
}
int main()
{
//在堆区开辟数据
int *p=func();
cout<<*p<<endl;
cout<<*p<<endl;
}
总结：
堆区数据有程序员管理开辟和释放。
堆区数据利用new关键字进行开辟内存。
1.3 new操作符
C++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
语法：new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针
#include <iostream>
using namespace std;
int *func()
{
//在堆区创建整型数据
//new返回的是 该创建数据类型的指针
//int* 是接受这个地址并且解引用
int *a = new int(18);
return a;
}
void test01()
{
int *p = func();
cout << *p << endl;
cout << *p << endl;
cout << *p << endl;
delete p;
cout << *p << endl; //不知道为什么，这个在Mac上的vscode上可以输出
}
void test02()
{
//创建一个10整型数据的数组，在堆区
int *arr = new int[10]; //代表数组由10个元素
for (int i = 0; i < 10; i++)
{
arr[i] = i + 100;
}
for (int i = 0; i < 10; i++)
{
cout << arr[i] << endl;
}
//释放堆区数组
//如果不加[],只释放了第一个指针，后面的指针被称为野指针。
delete[] arr;
}
int main()
{
test01();
test02();
}
2. 引用
2.1 引用的基本使用
作用：给变量起别名
语法：数据类型 &别名 = 原名
2.2 引用的注意事项
● 引用必须初始化
● 引用在初始化后，不可以改变
#include <iostream>
using namespace std;
//引用必须要初始化 如int &b；是错误的
//引用一旦初始化后，局部可以更改
int main()
{
int a = 10;
int &b = a;
cout << b << endl;
int c = 30;
b = c; //这是赋值操作，不是更改引用
cout << b << endl;
}2.3 引用做函数参数
作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参
代码：
#include <iostream>
using namespace std;
// 值传递
void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
// 地址传递
void swap02(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
// 引用传递
void swap03(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int a=11;
int b=888;
swap01(a,b);
cout<<"a="<<a<<"\tb="<<b<<endl;
swap02(&a,&b);
cout<<"a="<<a<<"\tb="<<b<<endl;
int c=777;
int d=12222;
swap03(c,d);
cout<<"c="<<c<<"\td="<<d<<endl;
}运行结果：
总结：总结：通过引用参数产生的效果同按地址传递是一样的，引用的语法更清楚简单。
2.4 引用做函数返回值
#include <iostream>
using namespace std;
int &test01()
{
int a = 10;
//return a;
}
int &test02()
{
static int a = 99;
return a;
}
int main()
{
//不能返回局部变量的引用
int &ret = test01();
//非法操作
cout << "ret=" << ret << endl;
cout << "ret=" << ret << endl;
//如果函数做左值，那么必须返回引用
int &ret2 = test02();
cout << "ret=" << ret2 << endl;
cout << "ret=" << ret2 << endl;
test02() = 1000;
cout << "ret=" << ret2 << endl;
cout << "ret=" << ret2 << endl;
}2.5 引用的本质
本质：引用的本质在c++内部实现是一个指针常量
也就是指针的指向不可以更改，而指针指向的值可以改，也就符合了引用定义后就不能修改的原则
#include<iostream>
using namespace std;
// 发现是引用 转换为int* const ref = &a；
void func(int &ref)
{
ref=100; // ref是引用，转换为*ref = 100
}
int main()
{
int a=11;
//自动转换为int* const ref = &a；指针常量是指针指向不可改，也说明为什么引用不可改
int &ref=a;
ref=20; // 发现是引用 转换为*ref = 20；
cout<<"a="<<a<<endl;
cout<<"ref="<<ref<<endl;
func(a);
return 0;
}总结：C++推荐用引用技术，是因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了。
2.6 常量引用
#include <iostream>
using namespace std;
// 引用使用的场景，通常用来修饰形参,如果不加const，就会可能无意被修改，特别是以后代码量大的时候，
// 可能会忘记自己曾经写的这个值能不能改
void showValue(int &val)
{
val=10088;
cout << val << endl;
}
void showValueTwo(const int &val)
{
// val=888; // 错误，这里就不能改了
cout<<val<<endl;
}
int main()
{
// 函数中利用常量引用防止误操作修改实参
int a = 10;
showValue(a);
cout << "a=" << a << endl;
}3. 函数的提高
3.1 函数的默认参数
3.2 函数占位参数
c++中函数的参数列表可以用占位参数，用来做占位，调用函数时必须填补该位置。
语法：返回值类型 函数名 （数据类型）{}
也可以这些写
3.3 函数重载
3.3.1 函数重载概述
作用：函数名可以相同，提高复用性
3.3.2 函数重载注意事项
● 引用作为重载条件
● 函数重载碰到函数默认参数
#include<iostream>
using namespace std;
// 函数重载的注意事项
// 1.引用作为重载的条件
//假如func(10)调用的是这个的话，那么是int &a = 10； 不合法
// 10存储在全局区的常量区，而引用必须要一个合法的内存空间，要么在栈区要么在堆区。
// 所以这样引用明显不合法
void func(int &a)
{
cout<<"func(int &a)'s call of"<<endl;
}
void func(const int &a) // const int &a = 10;
{
cout<<"func(const int &a)'s call of"<<endl;
}
void func2(int a,int b=10)
{
cout<<"func(int a,int b=10)'s call of"<<endl;
}
void func2(int a)
{
cout<<"func(int a)'s call of"<<endl;
}
int main()
{
int a=10; //调用的是a是一个变量，可读可写，所以引用的是第一个函数
func(a);
func(10); //
// !func2(10); error
// because There are
// multiple instances of overloaded function "func2"
// that match the parameter list
return 0;
}总结：
● 写函数重载的时候不要写默认参数，容易发生错误。
4.类和对象
4.2 对象的初始化和清理
4.2.1 构造函数和析构函数
构造函数：
1. 构造函数没有返回值
2. 构造函数可以重载
3. 程序在调用对象时会自动调用构造，而且只调用一次析构函数：
1. 析构函数没有返回值
2. 析构函数没有参数不可以重载
3. 程序在对象销毁前会自动调用析构函数，无需手动调用，而且只会调用一次4.2.2 构造函数的分类及调用
两种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
example：
#include <iostream>
using namespace std;
class Person
{
private:
/* data */
public:
Person();
Person(int a);
Person(const Person &a);
~Person();
int age;
};
Person::Person()
{
cout << "Person's call of nonparametric constructor" << endl;
}
Person::Person(int a)
{
age = a;
cout << "Person's call of parametric constructor" << endl;
}
Person::Person(const Person &p) //就是把一个对象的所有值拷贝给另一个对象
{
age = p.age;
cout << "Person's call of copy constructor" << endl;
}
Person::~Person()
{
cout << "Person's call of destructor" << endl;
}
// call fo
void test01()
{
// 1.括号法
// Person p1; //默认构造函数调用
// Person p2(10); // 有参构造函数
// Person p3(p2); //拷贝构造函数
//! 注意事项
// 调用默认构造函数的时候，不要加（）
// 因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
//? Person p1();
// 比如 void test(); 这样
// cout << "p2's age:" << p2.age << endl;
// cout << "p3's age:" << p3.age << endl;
// 2.显示法
// Person p11;
// Person p21 = Person(10); //有参调用
// Person p31 = Person(p21); //拷贝构造函数
// Person(20); // 匿名对象 // 特点：当前行执行结束后，系统会立即回收匿名对象
// cout << "aaaaa" << endl;
// 注意事项2:
// 不要利用拷贝构造函数初始化匿名对象
// 编译器会认为是 Person （p3） == Person p3；
//Person(p31);
// 3.隐式调用
Person p4=10; // Person p4 = Person(10);
Person p5=p4;
}
int main()
{
test01();
return 0;
}4.2.3 拷贝构造函数调用时机
#include <iostream>
using namespace std;
class Person
{
private:
/* data */
public:
Person();
Person(int a);
Person(const Person &a);
~Person();
int m_age;
};
Person::Person()
{
// 无参构造，也就是默认构造
cout << "Person's call of nonparametric constructor" << endl;
}
Person::Person(int age)
{
m_age = age;
cout << "Person's call of parametric constructor" << endl;
}
Person::Person(const Person &p)
{
m_age = p.m_age;
cout << "Person's call of copy constructor" << endl;
}
Person::~Person()
{
cout << "Person's call of destructor" << endl;
}
// 1.使用一个以及创建完毕的对象来初始化一个新对象
void test01()
{
Person p1(20);
Person p2(p1);
cout << "p2's age is:" << endl;
}
// 2.值传递的方式给函数参数传值
void doWork(Person p)
{
}
void test02()
{
Person p; // 默认构造
doWork(p); // 拷贝构造
}
// 3.值方式返回局部对象
Person dowork2()
{
Person p11;
cout<<(int*)&p11<<endl;
return p11; // 拷贝构造
}
void test03()
{
Person p=dowork2();
cout<<(int*)&p<<endl;
}
int main()
{
//test01();
test03();
return 0;
}4.2.4 拷贝构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下:
● 如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造
● 如果用户定义拷贝构造函数, C++不会再提供其他构造函数
class Person {
public:
Person() {
cout << "无参构造函数!" << endl;
mAge = 0;
}
Person(int age) {
cout << "有参构造函数!" << endl;
mAge = age;
}
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
mAge = p.mAge;
}
//析构函数在释放内存之前调用
~Person() {
cout << "析构函数!" << endl;
}
public:
int mAge;
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
Person man(100); //p对象已经创建完毕
Person newman(man); //调用拷贝构造函数
Person newman2 = man; //拷贝构造
//Person newman3;
//newman3 = man; //不是调用拷贝构造函数，赋值操作
}
//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
Person p; //无参构造函数
doWork(p);
}
//3. 以值方式返回局部对象
Person doWork2()
{
Person p1;
cout << (int *)&p1 << endl;
return p1;
}
void test03()
{
Person p = doWork2();
cout << (int *)&p << endl;
}
int main() {
//test01();
//test02();
test03();
system("pause");
return 0;
}
4.2.5 深拷贝与浅拷贝
深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
4.2.6 初始化列表
#include<iostream>
using namespace std;
class Student {
public:
Student(int a, int s, int h):m_Age(a), m_Score(s), m_Hight(h){}
private:
int m_Age;
int m_Score;
int m_Hight;
}
int main() {
Student s1;
return 0;
}4.2.7 类对象作为类成员
#include<iostream>
using namespace std;
class Phone {
public:
Phone(string name) {
m_PhoneName = name;
}
string m_PhoneName;
}
class Student {
public:
Student(int a, int s, int h):m_Age(a), m_Score(s), m_Hight(h){}
Phone m_Phone;
private:
int m_Age;
int m_Score;
int m_Hight;
}
int main() {
Student s1;
return 0;
}4.2.8 静态成员
静态成员就是类中的成员变量和成员函数前面加上static，就是静态成员
- 静态成员变量：
- 所有对象共享一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
- 静态成员函数：
- 所有对象共享一个函数
- 静态成员函数只能访问静态成员变量
4.3 C++对象模型和this指针
4.3.2 成员变量和成员函数分开存储
#include<iostream>
using namespace std;
// 类的大小为类的非静态成员变量
// 类的成员函数和静态成员函数不在类的存储空间中
// 此时类的大小为4
class Person {
static int m_Score;
int m_Age;
void run() {
cout << "run" << endl;
}
}
// 空类的大小为1
class Person1 {
}
int main() {
cout << sizeof(Person()) << endl;
return 0;
}4.3.2 this指针
通过前面一节我们知道C++中成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型对象会共用一块代码
那么这一块代码究竟是怎么区分那个对象调用自己的呢
C++通过提供特殊对象指针，this指针，解决上述问题，this指针指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可
this指针的用途：
this指针的本质是指针常量，this的指向不可以改变
- 当形参和成员变量同名时，用来区分二者
- 在类的非静态成员函数中返回对象本身，可使用return *this
//
// main.cpp
// this指针
//
// Created by ChengBei's iMac on 2021/9/8.
//
#include <iostream>
using namespace std;
class Person {
public:
Person(int age) {
m_Age = age;
}
void addPersonAge(int age) {
m_Age = m_Age + age;
}
// 返回类的本身，可以链式调用
// 这里为什么要返回引用呢，因为要引用传递，放回这个类的本身，而不是它的拷贝
Person& addPersonAgeTwo(int age) {
m_Age += age;
return *this; // 为什么返回的是this呢，因为this指向的是这个对象的指针，所以*this是这个对象本身
}
int m_Age = 0;
};
int main(int argc, const char * argv[]) {
Person p1(10);
p1.addPersonAge(10);
Person p2(20);
p2.addPersonAgeTwo(30).addPersonAge(20);
cout << p1.m_Age << endl;
cout << p2.m_Age << endl;
return 0;
}
4.3.4 const修饰成员函数
常函数：
- 成员函数前面加上const后称为常函数
- 常函数内不可以修改成员属性
- 成员属性内加关键字mutable后，在常函数中依然可以修改
常对象：
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数
4.5 运算符重载
4.5.1 加号运算符重载
作用：实现两个自定义数据的相加
4.5.6 继承同名成员处理方式
- 子类对象可以直接访问到子类中同名成员
- 子类对象加作用域可以访问到父类同名成员
- 当子类与父类拥有同名的成员函数，子类会隐藏父类中的成员函数，这时候加作用域可以访问到父类中的成员函数
5. 文件操作
程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放。
通过文件可以将数据存储。
文件类型分为两种：
1.文本文件：文件以文本ASCII码形式存储在计算机中
2.二进制文件：文件以文本二进制形式存储在计算机中
操作文件三大类：
- ofstream：写操作
- ifstream：读操作
- fstream：读写操作
4.7 多态
4.7.1 多态的基本概念：
多态分为两类：
- 静态多态：函数重载和运算符重载属于静态多态，复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态的区别：
- 静态多态的地址早绑定 - 编译阶段确定函数地址
- 动态多态的地址晚绑定 - 运行阶段确定函数地址（因为运行时才确定到底走哪个函数）
4.7.5 虚析构和纯虚析构
多态使用时，如果子类有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象的问题
- 都需要有具体的函数实现
区别：
- 如果是纯虚析构，该类属于抽象类，无法实例化
总结：
- 虚析构和纯虚析构就是用来解决通过父类指针释放子类对象的
- 如果子类中没有堆区数据，可以不写虚析构或纯虚析构
- 拥有纯虚析构的函数也属于抽象类
5.1 文本文件
5.1.1 写文件
写文件步骤如下：
1.包含头文件
#include<fstream>
2.创建流对象
ofstream.ofs;
3.打开文件
ofs.open("文件路径",打开方式)；
4.写数据
ofs<<"写入"；
5.关闭文件
ofs.close();文件打开方式：
| 打开方式 | 解释: | |
|---|---|---|
| ios::in | 为读文件而打开文件 | |
| ios::out | 为写文件而打开文件 | |
| ios::ate | 初始位置：文件尾 | |
| ios::app | 追加方式写文件 | |
| ios::trunc | 如果文件存在先删除，再创建 | |
| iOS::binary | 二进制方式 |
注意：文件打开方式可以配合|使用
用二进制方式写文件 ios::binary | ios::out
5.1.2 读文件
写文件步骤如下：
1.包含头文件
#include<fstream>
2.创建流对象
ifstream ifs;
3.打开文件
ofs.open("文件路径",打开方式)；
4.写数据
四种方式读取
5.关闭文件
ifs.close();文件打开方式：
| 打开方式 | 解释: | |
|---|---|---|
| ios::in | 为读文件而打开文件 | |
| ios::out | 为写文件而打开文件 | |
| ios::ate | 初始位置：文件尾 | |
| ios::app | 追加方式写文件 | |
| ios::trunc | 如果文件存在先删除，再创建 | |
| iOS::binary | 二进制方式 |
5.2 二进制文件
以二进制的方式对文件进行读写操作
打开方式要指定为 ios::binary
5.2.1 写文件
二进制方式写文件主要利用流对象调用成员函数write
函数原型 ：ostream& write(const char * buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
#include <fstream>
#include <string>
using namespace std;
class Person
{
public:
char m_Name[64];
int m_Age;
};
//二进制文件 写文件
void test01()
{
//1、包含头文件
//2、创建输出流对象
ofstream ofs("person.txt", ios::out | ios::binary);
//3、打开文件
//ofs.open("person.txt", ios::out | ios::binary);
Person p = {"张三" , 18};
//4、写文件
ofs.write((const char *)&p, sizeof(p));
//5、关闭文件
ofs.close();
}
int main() {
test01();
return 0;
}
总结：
- 文件输出流对象 可以通过write函数，以二进制方式写数据
5.2.2 读文件
二进制方式读文件主要利用流对象调用成员函数read
函数原型：istream& read(char *buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数
#include <fstream>
#include <string>
using namespace std;
class Person
{
public:
char m_Name[64];
int m_Age;
};
void test01()
{
ifstream ifs("person.txt", ios::in | ios::binary);
if (!ifs.is_open())
{
cout << "文件打开失败" << endl;
}
Person p;
ifs.read((char *)&p, sizeof(p));
cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
class Solution {
public:
int integerBreak(int n) {
vector<int> dp(n + 1);
dp[2] = 1;
for (int i = 3; i <= n ; i++) {
for (int j = 1; j < i - 1; j++) {
dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
}
}
return dp[n];
}
};
5
i = 3 dp[3] = ------------- 本文结束 感谢阅读 -------------