#include<iostream> using namespace std; //内存分区模型
//代码区，存放二进制代码，由操作系统进行管理
//全局区，存放全局变量、静态变量、常量（字符串常量和const修饰的全局常量）
//栈区，存放函数参数值、局部变量等，由编译器自动分配释放
//堆区，由程序员分配和释放，若程序员不，程序结束时由操作系统回收
//内存四区意义，不同区域存放的数据赋予不同的生命周期，给我们更大的灵活编程 //程序运行前：代码区，全局区
//程序运行后：栈区，堆区 //全局变量
int g_a = ;
int g_b = ; //const修饰的全局常量
const int c_g_a = ;
const int c_g_b = ; int main()
{
//局部变量
int a = ;
int b = ;
cout << "局部变量地址为 " << (int)&a << endl;
cout << "局部变量地址为 " << (int)&b << endl;
cout << "全局变量地址为 " << (int)&g_a << endl;
cout << "全局变量地址为 " << (int)&g_b << endl; //静态变量
static int s_a = ;
static int s_b = ;
cout << "静态变量地址为 " << (int)&s_a << endl;
cout << "静态变量地址为 " << (int)&s_b << endl; //字符串常量
string s1 = "s1";
string s2 = "s2";
cout << "字符串常量地址为 " << (int)&s1 << endl;
cout << "字符串常量地址为 " << (int) & "s2" << endl; //const修饰的全局常量
cout << "const修饰的全局常量 " << (int)&c_g_a << endl;
cout << "const修饰的全局常量 " << (int)&c_g_b << endl; //const修饰的局部常量
const int c_l_a = ;
const int c_l_b = ;
cout << "const修饰的局部常量 " << (int)&c_l_a << endl;
cout << "const修饰的局部常量 " << (int)&c_l_b << endl; system("pause"); return ;
}
内存分区模型
#include<iostream> using namespace std; int* func(int b) //形参数据也会存放在栈区
{
int a = ;
return &a; //不要返回局部变量的地址，局部变量存放在栈区，栈区开辟的数据由编译器自动释放
} int main()
{
int* p = func(); cout << *p << endl; //第一次打印正确，是因为编译器做了保留
cout << *p << endl; //第二次打印错误 system("pause"); return ;
}
栈区
#include<iostream> using namespace std; int* func()
{
int* p = new int(); //利用new关键字可以将数据开辟到堆区
return p; //指针本质上也是局部变量，放在栈上，但指针保存的数据是放在堆区
} //栈：int* p 0x0011
//堆：0x0011 10
int main()
{
int* p = func(); cout << *p << endl;
cout << *p << endl; system("pause"); return ;
}
堆区
#include<iostream> using namespace std; int* func()
{
int* p = new int();
return p;
} int main()
{
int* p = func(); cout << *p << endl;
cout << *p << endl; delete p; //cout << *p << endl; //报错
cout << "------------------------------------" << endl; //堆区开辟数组 int* arr = new int[]; for (int i = ; i < ; i++)
{
arr[i] = i + ;
} for (int i = ; i < ; i++)
{
cout << arr[i] << endl;
} delete[] arr; system("pause"); return ;
}
new操作符
#include<iostream> using namespace std; int main()
{
int a = ;
int& b = a; //给变量起别名 cout << "a = " << a << endl;
cout << "b = " << b << endl; b = ; cout << "a = " << a << endl;
cout << "b = " << b << endl; system("pause"); return ;
}
引用的基本使用
#include<iostream> using namespace std; int main()
{ int a = ;
int b = ; //引用必须初始化
//int& c; //引用初始化后不可以改变
int& c = a;
c = b; //这是赋值操作 cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl; system("pause"); return ;
}
引用注意事项
#include<iostream> using namespace std; //值传递
void mySwap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
} //地址传递
void mySwap02(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
} //引用传递
void mySwap03(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
} int main()
{
int a = ;
int b = ; //mySwap01(a, b); //mySwap02(&a, &b); mySwap03(a, b); cout << "a = " << a << endl;
cout << "b = " << b << endl; system("pause"); return ;
}
引用做函数参数
#include<iostream> using namespace std; //返回局部变量引用
int& test01()
{
int a = ;
return a;
} //返回静态变量引用
int& test02()
{
static int a = ;
return a;
} int main()
{
//不要返回局部变量引用
int& ref = test01();
cout << "ref = " << ref << endl;
cout << "ref = " << ref << endl; //返回静态变量引用
int& ref2 = test02();
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl; //函数调用作为左值，必须返回引用
test02() = ;
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl; system("pause"); return ;
}
引用做函数返回值
#include<iostream> using namespace std; void func(int& ref)
{
ref = ;
} int main()
{
int a = ; //引用本质是在C++内部实现一个指针常量
//指针常量，指针指向不可以修改，即引用不可以修改
//int* const ref = &a;
int& ref = a; //*ref = 20;
ref = ; cout << "a = " << a << endl;
cout << "ref = " << ref << endl; func(a); cout << "a = " << a << endl;
cout << "ref = " << ref << endl; system("pause"); return ;
}
引用的本质
#include<iostream> using namespace std; //常量引用通常用来修饰形参
void showValue(const int& v)
{
//v += 10;
cout << "v = " << v << endl;
} int main()
{
//常量引用主要用来修饰形参，防止误操作，即防止形参改变实参 //错误，需要加一个const修饰
//int& ref = 10; //int temp = 10; const int& ref = temp;
const int& ref = ; //ref = 100; //不可以修改 //函数中利用常量引用防止误操作修改实参
int a = ;
showValue(a); system("pause"); return ;
}
常量引用
#include<iostream> using namespace std; //函数参数某个位置有默认值，那么从这个位置往后，从左到右，必须都要有默认值
int func(int a, int b = , int c = )
{
return a + b + c;
} //如果函数声明有默认值，函数实现就不能有默认值，二者冲突
///函数声明
int func2(int a = , int b = );
//函数实现
int func2(int a, int b)
{
return a + b;
} int main()
{
cout << "return = " << func(, ) << endl; // cout << "return = " << func2(, ) << endl; // system("pause"); return ;
}
函数默认参数
#include<iostream> using namespace std; //函数占位参数，也可以有默认值
void func(int a, int)
{
cout << "this is func" << endl;
} int main()
{
func(, ); system("pause"); return ;
}
函数占位参数
#include<iostream> using namespace std; //函数重载条件：
//同一作用域下
//函数名称相同
//函数参数类型不同、个数不同、顺序不同
//注：函数返回值不同不可以作为函数重载的满足条件 void func()
{
cout << "func()调用" << endl;
} void func(int a)
{
cout << "func(int a)调用" << endl;
} void func(double d)
{
cout << "func(double d)调用" << endl;
} void func(int a, double d)
{
cout << "func(int a, double d)调用" << endl;
} void func(double d, int a)
{
cout << "func(double d, int a)调用" << endl;
} int main()
{
func();
func();
func(1.1);
func(, 1.1);
func(1.1, ); system("pause"); return ;
}
函数重载概述
#include<iostream> using namespace std; //引用作为重载条件
void func(int& a)
{
cout << "func(int& a)调用" << endl;
}
void func(const int& a)
{
cout << "func(const int& a)调用" << endl;
} //函数重载碰到函数默认参数
void func2(int a, int b = )
{
cout << "func2(int a, int b = 10)调用" << endl;
}
void func2(int a)
{
cout << "func2(int a)调用" << endl;
} int main()
{
int a = ;
func(a); //调用无const
func(); //调用有const func2(, ); //此处填一个参数会产生歧义 system("pause"); return ;
}
函数重载注意事项
#include<iostream> using namespace std; //类和对象
//面向对象三大特征：封装、继承、多态
//万物皆对象，对象有属性和行为
//车类，车
//？ //设计一个圆类求其周长
const double PI = 3.14;
class Circle
{
public: int r; double zhouChang()
{
return * PI * r;
}
}; int main()
{
Circle c;
c.r = ;
cout << "圆的周长 = " << c.zhouChang() << endl; system("pause"); return ;
}
封装意义（1）
#include<iostream> using namespace std; class Student
{
public: string m_name;
int m_id; void setName(string name)
{
m_name = name;
} void setId(int id)
{
m_id = id;
} void showStudent()
{
cout << "name = " << m_name << " " << "id = " << m_id << endl;
}
}; int main()
{
Student s;
s.m_name = "张三";
s.m_id = ;
//s.setName("李四");
s.showStudent(); system("pause"); return ;
}
学生类示例
#include<iostream> using namespace std; //public 公共权限，类内类外均可以访问
//protected 保护权限，类内可以访问类外不可以访问
//private 私有权限，类内可以访问类外不可以访问 class Preson
{
public:
string m_name; protected:
string m_car; private:
int m_passWord;
}; int main()
{
Preson p;
p.m_name = "张三";
//p.m_car;
//p.m_passWord; system("pause"); return ;
}
封装意义（2）
#include<iostream> using namespace std; class C1
{
//默认为私有权限
int m_c1;
}; struct C2
{
//默认为公共权限
int m_c2;
}; int main()
{ C1 c1;
//c1.m_c1; C2 c2;
c2.m_c2 = ; system("pause"); return ;
}
class与struct区别
#include<iostream> using namespace std; class Preson
{
private:
string m_name; int m_age; string m_lover; public:
void setName(string name)
{
m_name = name;
} string getName()
{
return m_name;
} void setAge(int age)
{
if (age < || age > )
{
cout << "你是妖精吧" << endl;
}
m_age = age;
} void setLover(string lover)
{
m_lover = lover;
} string getLover()
{
return m_lover;
}
}; int main()
{
Preson p;
p.setName("张三");
cout << "m_name = " << p.getName() << endl;
p.setAge();
p.setLover("波多野结衣");
cout << "m_lover = " << p.getLover() << endl; system("pause"); return ;
}
成员属性设置为私有
#include<iostream> using namespace std; #include "point.h"
#include "circle.h" //判断点和圆关系的全局函数
void isInCircle(Circle& c, Point& p)
{
//两点之间距离^2
int ppDistance =
(c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY()); //半径^2
int rDistance = c.getR() * c.getR(); //判断
if (ppDistance == rDistance)
{
cout << "点在圆上" << endl;
}
else if (ppDistance > rDistance)
{
cout << "点在圆外" << endl;
}
else
{
cout << "点在圆内" << endl;
}
} int main()
{
//设置圆，半径为10，圆心坐标为(10,0)
Circle c;
c.setR();
Point center;
center.setX();
center.setY();
c.setCenter(center); //设置点
Point p;
p.setX();
p.setY(); //判断
isInCircle(c, p); system("pause"); return ;
}
判断点和圆的位置关系
#pragma once #include <iostream>
using namespace std; class Point
{
private:
//坐标X
int m_x;
//坐标Y
int m_y;
public:
//设置X
void setX(int x);
//获取X
int getX();
//设置Y
void setY(int y);
//获取Y
int getY();
};
point.h
#include "point.h" //设置X
void Point::setX(int x)
{
m_x = x;
} //获取X
int Point::getX()
{
return m_x;
} //设置Y
void Point::setY(int y)
{
m_y = y;
} //获取Y
int Point::getY()
{
return m_y;
}
point.cpp
#pragma once #include <iostream>
using namespace std; #include "point.h" class Circle
{
private:
//半径
int m_r;
//圆心，类中有类
Point m_center;
public:
//设置半径
void setR(int r);
//获取半径
int getR();
//设置圆心
void setCenter(Point center);
//获取圆心
Point getCenter();
};
circle.h
#include "circle.h" //设置半径
void Circle::setR(int r)
{
m_r = r;
} //获取半径
int Circle::getR()
{
return m_r;
} //设置圆心
void Circle::setCenter(Point center)
{
m_center = center;
} //获取圆心
Point Circle::getCenter()
{
return m_center;
}
circle.cpp
#include <iostream> using namespace std; //构造函数：创建对象时为对象成员属性赋值，由编译器自动调用 //析构函数：对象销毁前系统自动调用 //构造函数语法：
//没有返回值也不写void
//函数名与类名相同
//可以有参数，因此可以发生重载
//程序调用对象时会自动调用构造，无需手动调用且只会调用一次 //析构函数语法：
//没有返回值也不写void
//函数名与类名相同，前面加~
//不可以有参数，因此不可以发生重载
//对象销毁前会自动调用析构，无需手动调用且只会调用一次 class Preson
{
public:
//构造函数
Preson()
{
cout << "Preson构造函数调用" << endl;
}
//析构函数
~Preson()
{
cout << "Preson析构函数调用" << endl;
}
}; void test01()
{
Preson p;
} int main()
{
test01(); system("pause"); return ;
}
构造函数和析构函数
#include <iostream> using namespace std; //按参数分：有参构造，无参构造
//按类型分：普通构造，拷贝构造 //三种调用方式：括号法，显示法，隐式转换法 class Preson
{
public:
int age;
public:
//无参（默认）构造函数
Preson()
{
cout << "无参构造函数调用" << endl;
}
//有参构造函数
Preson(int a)
{
age = a;
cout << "有参构造函数调用" << endl;
}
//拷贝构造函数
Preson(const Preson& p)
{
age = p.age;
cout << "拷贝构造函数调用" << endl; }
//析构函数
~Preson()
{
cout << "析构函数调用" << endl;
}
}; //调用无参构造函数
void test01()
{
Preson p;
} //调用有参构造函数
void test02()
{
//括号法
Preson p1();
//Preson p2(); //调用无参构造函数不要这样写，编译器会认为是函数声明 //显示法
Preson p2 = Preson();
Preson p3 = Preson(p2);
//Preson(10) //这是匿名对象，当前行结束之后马上析构 //隐式转换法
Preson p4 = ; //Preson p4 = Preson(10);
Preson p5 = p4; //Preson p5 = Preson(p4);
//Preson p5(p4); //不能利用拷贝构造函数初始化匿名对象，编译器会认为是函数声明
} int main()
{
//test01(); test02(); system("pause"); return ;
}
构造函数分类及调用
#include <iostream> using namespace std; //拷贝构造函数调用三种情况：
//使用一个已经创建完毕的对象初始化一个新对象
//值传递方式给函数参数传值
//值传递方式返回局部对象 class Preson
{
public:
int age;
public:
//无参（默认）构造函数
Preson()
{
age = ;
cout << "无参构造函数调用" << endl;
}
//有参构造函数
Preson(int a)
{
age = a;
cout << "有参构造函数调用" << endl;
}
//拷贝构造函数
Preson(const Preson& p)
{
age = p.age;
cout << "拷贝构造函数调用" << endl; }
//析构函数
~Preson()
{
cout << "析构函数调用" << endl;
}
}; //使用一个已经创建完毕的对象初始化一个新对象
void test01()
{
Preson p1();
Preson p2(p1);
Preson p3 = p1;
} //值传递方式给函数参数传值
void doWork01(Preson p)
{ }
void test02()
{
Preson p;
doWork01(p);
} //值传递方式返回局部对象
Preson doWork02()
{
Preson p;
cout << (int)&p << endl;
return p;
}
void test03()
{
Preson p = doWork02();
cout << (int)&p << endl;
} int main()
{
//test01(); //test02(); test03(); system("pause"); return ;
}
拷贝构造函数调用时机
#include <iostream> using namespace std; //默认情况下，C++编译器至少给一个类添加三个函数
//默认无参构造函数
//默认析构函数
//默认拷贝构造函数 //若用户定义有参构造函数，C++编译器不再提供默认无参构造函数，但会提供默认拷贝构造函数
//若用户定义拷贝构造函数，C++编译器什么也不提供 class Preson
{
public:
int age;
public:
//无参（默认）构造函数
Preson()
{
cout << "无参构造函数调用" << endl;
}
//有参构造函数
Preson(int a)
{
age = a;
cout << "有参构造函数调用" << endl;
}
//拷贝构造函数
Preson(const Preson& p)
{
age = p.age;
cout << "拷贝构造函数调用" << endl; }
//析构函数
~Preson()
{
cout << "析构函数调用" << endl;
}
}; void test01()
{
Preson p1();
Preson p2(p1); //若不写拷贝构造函数，C++编译器会自动添加并做浅拷贝操作
cout << "p2年龄 = " << p2.age << endl;
} void test02()
{
Preson p1;
Preson p2();
Preson p3(p2); Preson p4;
Preson p5();
Preson p6(p5);
} int main()
{
//test01(); test02(); system("pause"); return ;
}
构造函数调用规则
#include <iostream> using namespace std; //浅拷贝：简单的赋值拷贝操作
//深拷贝：在堆区重新申请空间进行拷贝操作 class Preson
{
public:
int m_age;
int* m_hieght;
public:
//无参（默认）构造函数
Preson()
{
cout << "无参构造函数调用" << endl;
}
//有参构造函数
Preson(int age, int height)
{
m_age = age;
m_hieght = new int(height);
cout << "有参构造函数调用" << endl;
}
//拷贝构造函数
Preson(const Preson& p)
{
m_age = p.m_age;
m_hieght = new int(*p.m_hieght); //如果类属性是在堆区开辟的，一定要自己提供拷贝函数，防止浅拷贝带来的问题
cout << "拷贝构造函数调用" << endl; //如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来重复释放堆区问题
}
//析构函数
~Preson()
{
if (m_hieght != NULL)
{
delete m_hieght;
}
cout << "析构函数调用" << endl;
}
}; void test01()
{
Preson p1(, );
Preson p2(p1);
cout << "p1年龄 = " << p1.m_age << endl;
cout << "p1体重 = " << *p1.m_hieght << endl;
cout << "p2年龄 = " << p2.m_age << endl;
cout << "p2体重 = " << *p2.m_hieght << endl;
} int main()
{
test01(); system("pause"); return ;
}
浅拷贝与深拷贝
#include <iostream> using namespace std; class Preson
{
private:
int m_a;
int m_b;
int m_c;
public:
//传统方式
/*Preson(int a, int b, int c)
{
m_a = a;
m_b = b;
m_c = c;
}*/ Preson(int a, int b, int c) :m_a(a), m_b(b), m_c(c)
{ } void printPreson()
{
cout << "mA = " << m_a << endl;
cout << "mB = " << m_b << endl;
cout << "mC = " << m_c << endl;
}
}; int main()
{
Preson p(, , );
p.printPreson(); system("pause"); return ;
}
初始化列表
#include <iostream> using namespace std; //类1中包含另一个类2时，
//构造函数先执行类2在执行类1
//析构函数先执行类1在执行类2 class Phone
{
public:
string m_phoneName;
public:
Phone(string name)
{
m_phoneName = name;
cout << "Phone构造函数" << endl;
}
~Phone()
{
cout << "Phone析构函数" << endl;
}
}; class Preson
{
public:
string m_name;
Phone m_phoneNmae;
public:
Preson(string name, string pname) :m_name(name), m_phoneNmae(pname)
{
cout << "Preson构造函数" << endl;
}
~Preson()
{
cout << "Preson析构函数" << endl;
}
void playShow()
{
cout << m_name << " 使用 " << m_phoneNmae.m_phoneName << " 牌子手机" << endl;
}
}; void test01()
{
Preson p("张三", "IphoneX");
p.playShow();
} int main()
{
test01(); system("pause"); return ;
}
类中有类
#include <iostream> using namespace std; //静态成员变量：
//所有对象共享同一份数据
//在编译阶段分配内存
//类内声明类外初始化 class Preson
{
public:
static int m_a;
private:
static int m_b;
}; int Preson::m_a = ;
int Preson::m_b = ; void test01()
{
//通过对象访问
Preson p1;
p1.m_a = ;
cout << "p1.m_a " << p1.m_a << endl; //共享同一份数据
Preson p2;
p2.m_a = ;
cout << "p1.m_a " << p1.m_a << endl;
cout << "p2.m_a " << p2.m_a << endl; //通过类名访问
cout << "m_a " << Preson::m_a << endl; //cout << "m_b " << Preson::m_b << endl; //私有权限访问不到
} int main()
{
test01(); system("pause"); return ;
}
静态成员变量
#include <iostream> using namespace std; //静态成员函数：
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量 class Preson
{
public:
static int m_a;
int m_b;
public:
static void func1()
{
m_a = ;
//m_b = 100;
cout << "func1()调用" << endl;
}
private:
static void func2()
{
cout << "func2()调用" << endl;
}
}; int Preson::m_a = ; void test01()
{
//通过对象访问
Preson p1;
p1.func1(); //通过类名访问
Preson::func1(); //Preson::func2();
} int main()
{
test01(); system("pause"); return ;
}
静态成员函数
#include <iostream> using namespace std; //在C++中，类的成员变量和成员函数分开存储
//只有非静态成员变量占对象空间 class Preson
{
public:
Preson()
{ } int m_a; /*static int m_b; void func1()
{ } static void func2()
{ }*/
}; int main()
{
cout << sizeof(Preson) << endl; system("pause"); return ;
}
成员变量和成员函数分开存储
#include <iostream> using namespace std; //this指针指向被调用成员函数所属的对象
//this指针是隐含在每一个非静态成员函数内的一种指针
//this指针不需要定义，直接使用即可 //this指针用途：
//1、当形参和成员变量重名时，可以用this指针来区分
//2、在类的非静态成员函数中返回对象本身，可使用return *this class Preson
{ public:
int age;
public:
Preson(int age)
{
//1、
this->age = age;
}
//2、
Preson& presonAdd(Preson p)
{
this->age += p.age;
return *this;
}
}; void test01()
{
Preson p1();
cout << "p1.age = " << p1.age << endl; Preson p2();
p2.presonAdd(p1).presonAdd(p1).presonAdd(p1);
cout << "p2.age = " << p2.age << endl;
} int main()
{
test01(); system("pause"); return ;
}
this指针概念
#include <iostream> using namespace std; class Preson
{
public:
int m_age;
public:
void showClassName()
{
cout << "我是showClassName()" << endl;
}
void showPreson()
{
if (this == NULL)
{
return;
}
cout << "我是showPreson()" << endl;
}
}; void test01()
{
Preson* p = NULL;
p->showClassName();
p->showPreson();
} int main()
{
test01(); system("pause"); return ;
}
空指针访问成员函数
#include <iostream> using namespace std; //成员函数后加const称为常函数
//常函数内不可以修改成员属性
//成员属性在声明时加mutable关键字后，在常函数中依然可以修改 //声明对象前加const称为常对象
//常对象只能调用常函数 class Preson
{
public:
int m_a;
mutable int m_b;
public:
Preson()
{
m_a = ;
m_b = ;
}
//this指针本质为一个指针常量，指针指向不可以修改
//如果想指针指向的值也不可以修改，需声明常函数
void func1() const
{
//this = NULL; //不能修改指针指向 //this->m_a = 100; //不能修改指针指向的值 this->m_b = ;
}
}; void test01()
{
//常对象
const Preson p;
//p.m_a = 100;
p.m_b = ;
p.func1();
} int main()
{
test01(); system("pause"); return ;
}
常函数和常对象
#include <iostream> using namespace std; //全局函数做友元 class Building
{
friend void goodGay(Building* b); public:
string m_SittingRoom;
private:
string m_BedRoom;
public:
Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
}; void goodGay(Building* b)
{
cout << "好基友正在访问：" << b->m_SittingRoom << endl;
cout << "好基友正在访问：" << b->m_BedRoom << endl;
} void test01()
{
Building b;
goodGay(&b);
} int main()
{
test01(); system("pause"); return ;
}
全局函数做友元
#include <iostream> using namespace std; //类做友元 class Building; class GoodGay
{
private:
Building* b;
public:
GoodGay();
void visit();
}; class Building
{
friend class GoodGay; public:
string m_SittingRoom;
private:
string m_BedRoom;
public:
Building();
}; Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
} GoodGay::GoodGay()
{
b = new Building;
} void GoodGay::visit()
{
cout << "好基友正在访问：" << b->m_SittingRoom << endl;
cout << "好基友正在访问：" << b->m_BedRoom << endl;
} void test01()
{
GoodGay gg;
gg.visit();
} int main()
{
test01(); system("pause"); return ;
}
类做友元
#include <iostream> using namespace std; //成员函数做友元 class Building; class GoodGay
{
private:
Building* b;
public:
GoodGay();
void visit();
void visit2();
}; class Building
{
friend void GoodGay::visit(); public:
string m_SittingRoom;
private:
string m_BedRoom;
public:
Building();
}; Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
} GoodGay::GoodGay()
{
b = new Building;
} void GoodGay::visit()
{
cout << "好基友正在访问：" << b->m_SittingRoom << endl;
cout << "好基友正在访问：" << b->m_BedRoom << endl;
} void GoodGay::visit2()
{
cout << "好基友正在访问：" << b->m_SittingRoom << endl;
//cout << "好基友正在访问：" << b->m_BedRoom << endl;
} void test01()
{
GoodGay gg;
gg.visit();
gg.visit2();
} int main()
{
test01(); system("pause"); return ;
}
成员函数做友元
#include <iostream> using namespace std; //加号运算符重载
//实现两个自定义数据类型相加运算 class Preson
{
public:
int m_a;
int m_b;
public:
Preson()
{ }
Preson(int a, int b)
{
this->m_a = a;
this->m_b = b;
}
//成员函数实现
/*Preson operator+(Preson& p)
{
Preson val;
val.m_a = this->m_a + p.m_a;
val.m_b = this->m_b + p.m_b;
return val;
}*/
}; //全局函数实现
Preson operator+(Preson& p1, Preson& p2)
{
Preson val(, );
val.m_a = p1.m_a + p2.m_a;
val.m_b = p1.m_b + p2.m_b;
return val;
} //运算符重载的同时也可以发生函数重载
Preson operator+(Preson& p1, int n)
{
Preson val(, );
val.m_a = p1.m_a + n;
val.m_b = p1.m_b + n;
return val;
} void test01()
{
Preson p1(, );
Preson p2(, ); Preson p3 = p1 + p2; Preson p4 = p3 + ; cout << "m_a = " << p3.m_a << endl;
cout << "m_b = " << p3.m_b << endl; cout << "m_a = " << p4.m_a << endl;
cout << "m_b = " << p4.m_b << endl;
} int main()
{
test01(); system("pause"); return ;
}
加号运算符重载
#include <iostream> using namespace std; //左移运算符重载
//可以输出自定义数据类型 class Preson
{
friend ostream& operator<<(ostream& cout, Preson& p); private:
int m_a;
int m_b;
public:
Preson(int a, int b)
{
this->m_a = a;
this->m_b = b;
}
//成员函数实现不了
//p << cout 不是我们想要的格式
}; //全局函数实现
ostream& operator<<(ostream& out, Preson& p)
{
out << "m_a = " << p.m_a << endl;
out << "m_b = " << p.m_b << endl;
return out;
} void test01()
{
Preson p(, );
cout << p << endl; //链式编程
} int main()
{
test01(); system("pause"); return ;
}
左移运算符重载
#include <iostream> using namespace std; //递增运算符重载 class myInt
{
friend ostream& operator<<(ostream& out, myInt mi); private:
int m_num;
public:
myInt()
{
m_num = ;
}
//前置++
myInt& operator++()
{
//先++在return
m_num++;
return *this;
}
//后置++
myInt operator++(int)
{
//先return在++
myInt mi = *this;
m_num++;
return mi;
}
}; ostream& operator<<(ostream& out, myInt mi)
{
out << mi.m_num;
return out;
} //前置++
void test01()
{
myInt mi;
cout << ++mi << endl;
cout << mi << endl;
} //后置++
void test02()
{
myInt mi;
cout << mi++ << endl;
cout << mi << endl;
} int main()
{
test01(); test02(); system("pause"); return ;
}
递增运算符重载
#include <iostream> using namespace std; //赋值运算符重载 class Preson
{
public:
int* m_age;
public:
Preson(int age)
{
m_age = new int(age);
}
Preson& operator=(Preson& 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;
}
~Preson()
{
if (m_age != NULL)
{
delete m_age;
m_age = NULL;
}
}
}; void test01()
{
Preson p1();
Preson p2();
Preson p3(); p3 = p2 = p1; cout << "p1年龄 = " << *p1.m_age << endl;
cout << "p2年龄 = " << *p2.m_age << endl;
cout << "p3年龄 = " << *p3.m_age << endl;
} int main()
{
test01(); int a = ;
int b = ;
int c = ; c = b = a; cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl; system("pause"); return ;
}
赋值运算符重载
#include <iostream> using namespace std; //关系运算符重载 class Preson
{
public:
string m_name;
int m_age;
public:
Preson(string name, int age)
{
this->m_name = name;
this->m_age = age;
}
bool operator==(Preson& p)
{
if (this->m_name == p.m_name && this->m_age == p.m_age)
{
return true;
}
else
{
return false;
}
}
bool operator!=(Preson& p)
{
if (this->m_name == p.m_name && this->m_age == p.m_age)
{
return false;
}
else
{
return true;
}
}
}; void test01()
{
Preson p1("张三", );
Preson p2("张三", ); if (p1 == p2)
{
cout << "p1==p2" << endl;
}
else
{
cout << "p1!=p2" << endl;
} if (p1 != p2)
{
cout << "p1!=p2" << endl;
}
else
{
cout << "p1==p2" << endl;
}
} int main()
{
test01(); system("pause"); return ;
}
关系运算符重载
#include <iostream> using namespace std; //函数调用运算符重载
//也称为仿函数()，没有固定写法，非常灵活 class myPrint
{
public:
void operator()(string s)
{
cout << s << endl;
}
}; void test01()
{
myPrint mp;
mp("hello world");
} class myAdd
{
public:
int operator()(int a, int b)
{
return a + b;
}
}; void test02()
{
myAdd ma;
int n = ma(, );
cout << "n = " << n << endl; //匿名对象调用
cout << "myAdd()(1000, 1000) = " << myAdd()(, ) << endl;
} int main()
{
test01(); test02(); system("pause"); return ;
}
函数调用运算符重载
#include <iostream> using namespace std; //继承：减少重复代码 //子类，父类
//派生类，基类 class basePage
{
public:
void header()
{
cout << "公共头部" << endl;
}
void footer()
{
cout << "公共底部" << endl;
}
}; class Java :public basePage
{
public:
void concent()
{
cout << "Java学习视频" << endl;
}
}; class Python :public basePage
{
public:
void concent()
{
cout << "Python学习视频" << endl;
}
}; class CPP :public basePage
{
public:
void concent()
{
cout << "CPP学习视频" << endl;
}
}; void test01()
{
Java ja;
ja.header();
ja.footer();
ja.concent(); Python py;
py.header();
py.footer();
py.concent(); CPP cp;
cp.header();
cp.footer();
cp.concent();
} int main()
{
test01(); system("pause"); return ;
}
继承基本语法
#include <iostream> using namespace std; //公有继承
class Base1
{
public:
int m_a;
protected:
int m_b;
private:
int m_c;
};
class Son1 :public Base1
{
void func()
{
m_a; //可访问，public权限
m_b; //可访问，protected权限
//m_c; //不可访问
}
};
void test01()
{
Son1 s1;
s1.m_a;
} //保护继承
class Base2
{
public:
int m_a;
protected:
int m_b;
private:
int m_c;
};
class Son2 :protected Base2
{
void func()
{
m_a; //可访问，protected权限
m_b; //可访问，protected权限
//m_c; //不可访问
}
};
void test02()
{
Son2 s2;
} //私有继承
class Base3
{
public:
int m_a;
protected:
int m_b;
private:
int m_c;
};
class Son3 :private Base3
{
void func()
{
m_a; //可访问，private权限
m_b; //可访问，private权限
//m_c; //不可访问
}
};
void test03()
{
Son3 s3;
} int main()
{
test01(); test02(); test03(); system("pause"); return ;
}
继承方式
#include <iostream> using namespace std; //父类中私有成员也被子类继承了，只是被编译器隐藏访问不到 class Base
{
public:
int m_a;
protected:
int m_b;
private:
int m_c;
}; class Son :public Base
{
public:
int m_d;
}; void test01()
{
cout << sizeof(Son) << endl; //
} int main()
{
test01(); system("pause"); return ;
}
继承中的对象模型
#include <iostream> using namespace std; //继承中先调用父类构造函数，在调用子类构造函数
//析构函数与构造函数调用顺序相反 class Base
{
public:
Base()
{
cout << "Base()构造函数" << endl;
}
~Base()
{
cout << "Base()析构函数" << endl;
}
}; class Son :public Base
{
public:
Son()
{
cout << "Son()构造函数" << endl;
}
~Son()
{
cout << "Son()析构函数" << endl;
}
}; void test01()
{
Son s;
} int main()
{
test01(); system("pause"); return ;
}
继承中构造函数与析构函数调用顺序
#include <iostream> using namespace std; //子类对象可以直接访问子类同名成员
//子类对象加作用域可以访问父类同名成员
//子类和父类有同名成员函数时，子类会隐藏父类同名成员函数，若想访问需加作用域 class Base
{
public:
int m_a;
public:
Base()
{
m_a = ;
}
void func()
{
cout << "Base func()调用" << endl;
}
void func(int a)
{
cout << "Base func(int a)调用" << endl;
}
}; class Son :public Base
{
public:
int m_a;
public:
Son()
{
m_a = ;
}
void func()
{
cout << "Son func()调用" << endl;
}
}; void test01()
{
Son s;
cout << "Son的m_a = " << s.m_a << endl;
cout << "Base的m_a = " << s.Base::m_a << endl; s.func();
s.Base::func();
s.Base::func();
} int main()
{
test01(); system("pause"); return ;
}
继承中同名成员处理方式
#include <iostream> using namespace std; class Base
{
public:
static int m_a;
public:
static void func()
{
cout << "Base func()调用" << endl;
}
static void func(int a)
{
cout << "Base func(int a)调用" << endl;
}
}; int Base::m_a = ; class Son :public Base
{
public:
static int m_a;
public:
static void func()
{
cout << "Son func()调用" << endl;
}
}; int Son::m_a = ; //同名成员属性
void test01()
{
//通过对象访问
Son s;
cout << "Son的m_a = " << s.m_a << endl;
cout << "Base的m_a = " << s.Base::m_a << endl; //通过类名访问
cout << "Son的m_a = " << Son::m_a << endl;
cout << "Base的m_a = " << Son::Base::m_a << endl;
} //同名成员函数
void test02()
{
//通过对象访问
Son s;
s.func();
s.Base::func(); //通过类名访问
Son::func();
//Base::代表作用域
Son::Base::func();
Son::Base::func();
} int main()
{
test01(); test02(); system("pause"); return ;
}
继承中同名静态成员处理方式
#include <iostream> using namespace std; class Base1
{
public:
int m_a;
public:
Base1()
{
m_a = ;
}
}; class Base2
{
public:
int m_a;
public:
Base2()
{
m_a = ;
}
}; class Son :public Base1, public Base2
{
public:
int m_c;
int m_d;
public:
Son()
{
m_c = ;
m_d = ;
}
}; void test01()
{
Son s;
cout << sizeof(Son) << endl;
cout << s.Base1::m_a << endl;
cout << s.Base2::m_a << endl;
} int main()
{
test01(); system("pause"); return ;
}
多继承语法
#include <iostream> using namespace std; //菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费且毫无意义
//利用虚继承解决菱形继承问题 class Animal
{
public:
int m_age;
}; class Yang :virtual public Animal
{ }; class Tuo :virtual public Animal
{ }; class YangTuo :public Yang, public Tuo
{ }; void test01()
{
YangTuo yt;
yt.Yang::m_age = ;
yt.Tuo::m_age = ; cout << "yt.Yang::m_age = " << yt.Yang::m_age << endl;
cout << "yt.Tuo::m_age = " << yt.Tuo::m_age << endl;
cout << "yt.m_age = " << yt.m_age << endl;
} int main()
{
test01(); system("pause"); return ;
}
菱形继承
#include <iostream> using namespace std; //多态满足条件：
//有继承关系
//子类重写父类中的虚函数 //多态使用条件
//父类指针或引用指向子类对象
//重写时，函数返回类型、函数名、参数列表要完全一致 class Animal
{
public:
//虚函数
virtual void speak()
{
cout << "动物在说话" << endl;
}
}; class Cat :public Animal
{
public:
void speak()
{
cout << "小猫在说话" << endl;
}
}; class Dog :public Animal
{
public:
void speak()
{
cout << "小狗在说话" << endl;
}
}; void doSpeak(Animal& a)
{
a.speak();
} void test01()
{
Cat cat;
doSpeak(cat); Dog dog;
doSpeak(dog);
} int main()
{
test01(); system("pause"); return ;
}
多态的基本概念
#include <iostream> using namespace std; class jiSuanQi
{
public:
int m_num1;
int m_num2;
public:
virtual int getResult()
{
return ;
}
}; class jiajiSuanQi :public jiSuanQi
{
public:
int getResult()
{
return m_num1 + m_num2;
}
}; class jianjiSuanQi :public jiSuanQi
{
public:
int getResult()
{
return m_num1 - m_num2;
}
}; class chengjiSuanQi :public jiSuanQi
{
public:
int getResult()
{
return m_num1 * m_num2;
}
}; class chujiSuanQi :public jiSuanQi
{
public:
int getResult()
{
return m_num1 / m_num2;
} }; void test01()
{
//加法
jiSuanQi* jsq = new jiajiSuanQi;
jsq->m_num1 = ;
jsq->m_num2 = ;
cout << "加法 = " << jsq->getResult() << endl;
delete jsq; //减法
jsq = new jianjiSuanQi;
jsq->m_num1 = ;
jsq->m_num2 = ;
cout << "减法 = " << jsq->getResult() << endl;
delete jsq; //乘法
jsq = new chengjiSuanQi;
jsq->m_num1 = ;
jsq->m_num2 = ;
cout << "乘法 = " << jsq->getResult() << endl;
delete jsq; //除法
jsq = new chujiSuanQi;
jsq->m_num1 = ;
jsq->m_num2 = ;
cout << "除法 = " << jsq->getResult() << endl;
delete jsq;
} int main()
{
test01(); system("pause"); return ;
}
多态计算器
#include <iostream> using namespace std; //在多态中，通常父类中的虚函数是毫无意义的，主要都是调用子类中重写的内容
//因此可以将虚函数改为纯虚函数
//当类中有了纯虚函数，这个类也称为抽象类 //抽象类特点：
//无法实例化对象
//子类必须重写抽象类中的纯虚函数，否则也属于抽象类 class Base
{
public:
//纯虚函数
virtual void func() = ;
}; class Son :public Base
{
public:
void func()
{
cout << "func()调用" << endl;
}
}; void test01()
{
Base* base = NULL;
//base = new Base;
base = new Son;
base->func();
delete base;
} int main()
{
test01(); system("pause"); return ;
}
纯虚函数和抽象类
#include <iostream> using namespace std; class zhiZuoYinPin
{
public:
virtual void shaoShui() = ;
virtual void chongPao() = ;
virtual void heTa() = ;
void liuCheng()
{
shaoShui();
chongPao();
heTa();
}
}; class Coffee :public zhiZuoYinPin
{
void shaoShui()
{
cout << "加热农夫山泉" << endl;
}
void chongPao()
{
cout << "冲泡咖啡" << endl;
}
void heTa()
{
cout << "喝咖啡" << endl;
}
}; class Tea :public zhiZuoYinPin
{
void shaoShui()
{
cout << "加热百岁山" << endl;
}
void chongPao()
{
cout << "冲泡龙井" << endl;
}
void heTa()
{
cout << "喝龙井" << endl;
}
}; void doWork(zhiZuoYinPin* zzyp)
{
zzyp->liuCheng();
delete zzyp;
} void test01()
{
doWork(new Coffee);
doWork(new Tea);
} int main()
{
test01(); system("pause"); return ;
}
多态制作饮品
#include <iostream> using namespace std; //使用多态时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构函数
//解决办法：将父类中的析构函数改为虚析构或纯虚析构 //虚析构和纯虚析构
//共性：
//可以解决父类指针释放子类对象
//都需要有具体的函数实现
//区别：
//如果是纯虚析构函数，该类属于抽象类，无法实例化
//如果子类中没有堆区数据，可以不写虚析构或纯虚析构 class Animal
{
public:
virtual void speak() = ; Animal()
{
cout << "Animal()构造函数调用" << endl;
} //虚析构函数
/*virtual ~Animal()
{
cout << "Animal()虚析构函数调用" << endl;
}*/ //纯虚析构函数
virtual ~Animal() = ;
}; Animal::~Animal()
{
cout << "Animal()纯虚析构函数调用" << endl;
} class Cat :public Animal
{
public:
string* m_name; public:
Cat(string name)
{
cout << "Cat构造函数调用" << endl;
m_name = new string(name);
} virtual ~Cat()
{
cout << "Cat析构函数调用" << endl;
if (this->m_name != NULL)
{
delete m_name;
m_name = NULL;
}
} void speak()
{
cout << *m_name << "小猫在说话" << endl;
}
}; void test01()
{
Animal* a = new Cat("Tom");
a->speak(); //通过父类指针去释放，会导致子类对象清理不干净，造成内存泄露
delete a; //给父类增加一个虚析构函数或纯虚析构函数
} int main()
{
test01(); system("pause"); return ;
}
虚析构函数和纯虚析构函数
#include <iostream> using namespace std; //C++中对文件操作需包含头文件<fstream>
#include <fstream> //文件类型分为两种：
//文本文件，以ASCII码形式存储
//二进制文件，以二进制形式存储 //操作文件的三大类：
//ofstream，写操作
//ifstream，读操作
//fstream，写读操作 //文本文件，写文件步骤：
//包含头文件
//创建流对象
//打开文件
//写数据
//关闭文件 //文件打开方式：
//ios::in 为读文件而打开文件
//ios::out 为写文件而打开文件
//ios::ate 初始位置：文件尾
//ios::app 追加方式写文件
//ios::trunc 如果文件存在先删除，在创建
//ios::binary 二进制方式 //文件打开方式可以配合 | 操作符使用
//如二进制方式写文件 ios::binary | ios::out void test01()
{
ofstream ofs;
ofs.open("test.txt", ios::out);
ofs << "姓名 = 张三" << endl;
ofs << "性别 = 男" << endl;
ofs.close();
} int main()
{
test01(); system("pause"); return ;
}
文本文件（写文件）
#include <iostream> using namespace std; #include <fstream> //文本文件读文件步骤：
//包含头文件
//创建流对象
//打开文件并判断文件是否打开成功
//读数据
//关闭文件 void test01()
{
ifstream ifs;
ifs.open("test.txt", ios::in);
if (!ifs.is_open())
{
cout << "文件打开失败" << endl;
return;
} //
/*char buff[1024] = { 0 };
while (ifs >> buff)
{
cout << buff << endl;
}*/ //
/*char buff[1024] = { 0 };
while (ifs.getline(buff, sizeof(buff)))
{
cout << buff << endl;
}*/ //
char c;
while ((c = ifs.get()) != EOF)
{
cout << c;
} ifs.close();
} int main()
{
test01(); system("pause"); return ;
}
文本文件（读文件）
#include <iostream> using namespace std; #include <fstream> //ostream& write(char* buffer , int len)
//buffer指向内存中一段存储空间，len是读写字节数 class Preson
{
public:
char m_name[];
int m_age;
}; void test01()
{
ofstream ofs("Preson.txt", ios::out | ios::binary); Preson p{ "李四", }; ofs.write((const char*)&p, sizeof(p)); ofs.close();
} int main()
{
test01(); system("pause"); return ;
}
二进制文件（写文件）
#include <iostream> using namespace std; #include <fstream> //istream& read(char* buffer , int len)
//buffer指向内存中一段存储空间，len是读写字节数 class Preson
{
public:
char m_name[];
int m_age;
}; void test01()
{
ifstream ifs("Preson.txt", ios::in | ios::binary); if (!ifs.is_open())
{
cout << "文件打开失败" << endl;
return;
} Preson p; ifs.read((char*)&p, sizeof(p)); cout << "姓名 = " << p.m_name << endl;
cout << "年龄 = " << p.m_age << endl;
} int main()
{
test01(); system("pause"); return ;
}
二进制文件（读文件）
end