01.explicit的作用(了解)
class Maker
{
public:
//explicit只能放在构造函数前面，构造函数只有一个参数或其他参数有默认值时
explicit Maker(int n)//防止编译器优化Maker m=10;这种格式
{
}
};
int main()
{
//Maker m = 10;err
}
02.C++的堆区空间的申请和释放（重点）
1.申请和释放变量空间
1.为什么要有新的方法申请和释放堆区空间
因为用C语言的方式不会调用构造和析构函数
2.C++中申请堆区空间和释放堆区空间用什么关键字
申请堆区空间用new,释放空间用delete
class Maker
{
public:
Maker()
{
cout << "构造函数" << endl;
}
Maker(int a)
{
cout << "有参构造函数" << endl;
}
~Maker()
{
cout << "析构函数" << endl;
}
};
void test02()
{
//用new方式申请堆区空间，会调用类的构造函数
Maker *m = new Maker;
//释放堆区空间，会调用类的析构函数
delete m;
m = NULL;
Maker *m2 = new Maker(10);
delete m2;
m2 = NULL;
}
2.申请和释放数组空间
1.new创建基础类型的数组
void test01()
{
//申请基础数据类型的数组
int *pInt = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//不推荐
for (int i = 0; i < 10; i++)
{
pInt[i] = i + 1;
}
for (int i = 0; i < 10; i++)
{
cout << pInt[i] << " ";
}
cout << endl;
char *pChar = new char[64];
memset(pChar, 0, 64);
strcpy(pChar, "小话");
cout << pChar << endl;
//注意：如果new时有中括号，那么delete时也要有中括号
delete[] pInt;
delete[] pChar;
}
2.new创建对象数组
class Maker
{
public:
Maker()
{
cout << "构造函数" << endl;
}
Maker(int a)
{
cout << "有参构造函数" << endl;
}
~Maker()
{
cout << "析构函数" << endl;
}
};
void test02()
{
Maker *ms = new Maker[2];//调用无参构造
delete[] ms;
//大部分编译器不支持这种写法，(聚合初始化）
//Maker *ms2 = new Maker[2]{Maker(10), Maker(20)};
}
3.delete void*可能出错,不会调用对象的析构函数
void test03()
{
void *m = new Maker;
//如果用void*来接new的对象，那么delete时不会调用析构函数
delete m;
//在编译阶段，那么编译器就确定好了函数的调用地址，
//C++编译器不认识void*,不知道void*指向那个函数，所以不会调用析构函数
//这种编译方式叫静态联编
}
4.C和C++的申请和释放堆区空间不要混用
3.和C的共同和区别之处
共同：都是申请堆区空间和释放堆区空间
区别：C++的会调用构造和析构函数
03.静态成员（了解）
1.静态成员变量的生命周期是整个程序，作用域在类内
2.静态成员变量要在类内声明，类外初始化
3.静态成员变量属于类，不属于对象，是所有对象共享 共享为目的
4.静态成员变量可以用类访问，也可以用对象访问
class Maker
{
public:
Maker()
{
}
public:
//1.静态成员变量的生命周期是整个程序，作用域在类内
static int a;
};
//2.静态成员变量要在类内声明，类外初始化
int Maker::a = 100;
void test01()
{
//3.静态成员变量属于类，不属于对象，是所有对象共享
cout << Maker::a << endl;
Maker m;
cout << m.a << endl;
//4.静态成员变量可以用类访问，也可以用对象访问
}
5.静态成员函数只能访问静态成员变量
class Maker2
{
public:
Maker2()
{
}
//静态成员函数只能访问静态成员变量
static void setA(int a)
{
a2 = a;
cout << "a2=" << a2 << endl;
//a1 = a;不能访问普通成员变量
}
public:
int a1;
static int a2;
};
int Maker2::a2 = 200;
void test02()
{
Maker2::setA(300);
}
6.静态成员也有权限，如果为私有，类外也不可以访问
class Maker3
{
private:
static void func()
{
cout << "a3=" << a3 << endl;
}
private:
static int a3;
};
int Maker3::a3 = 300; //但是初始化变量可以的
void test03()
{
//Maker3::func();err
}
7.const修饰的静态成员变量，最好在类内初始化 目的是让大家共享不可修改的共享静态变量
//const修饰的静态成员变量最好在类内初始化
class Maker4
{
public:
const static int a = 20;
const static int b;
};
//类外也可以初始化
const int Maker4::b = 30;
8.普通成员函数可以访问静态成员变量 但不可通过类访问
class Maker5
{
public:
void func()
{
cout << "a=" << a << endl;
}
public:
static int a;
};
//类外也可以初始化
int Maker5::a = 30;
void test04()
{
Maker5 m;
m.func();
}
04.C++的对象模型（重点）
1.空类的大小是1.
2.类的成员函数不占用类的大小，静态成员变量不占用类的大小，静态成员函数不占用类的大小
3.普通成员变量占用类的大小
4.类的成员中，成员函数和成员变量是分开存储
05.this指针（重点难点）
1.每个对象都有一个隐藏的this指针，但不属于对象，是编译器添加的
2.编译器会把this指针传入成员函数内
3.this指针指向对象的存储空间
4.this的作用:
class Maker2
{
public:
//1.当形参名和成员变量名相同时，用this指针区分
Maker2(int id)
{
this->id = id;
}
//2.返回对象的本身
Maker2 &getMaker2()
{
return *this;//运算符重载时有用
}
public:
int id;
};
5.拓展
1.this指针指向的空间有没有存储静态成员变量？
没有
2.this指针的指向可以改变吗？
this指针的指向不能改变，也就是说this是Maker *const this;
6.防止空指针调用成员函数
class Maker
{
public:
Maker()
{
a = 20;
}
void printMaker()
{
if (this == NULL)
{
cout << "this==NULL" << endl;
return;
}
cout << this->a << endl;
}
private:
int a;
};
void test()
{
Maker *m = NULL;
m->printMaker();
}
06.常函数和常对象（重点）
1.常函数
1.在函数的()后面加上const，这个函数就是常函数
2.常函数内不能修改普通成员变量
3.const修饰的是this指针指向的空间中的变量不能改变
4.mutable修饰的成员变量在常函数中可以修改
class Maker
{
public:
Maker(int id, int age)
{
this->id = id;
this->age = age;
score = 100;
}
//常函数,1.函数的()后面添加const,该函数是常函数
void printMaker()const // ---------> // const Maker* const this
{
//id = 100;err //2.常函数内不能修改普通成员变量
//3.const修饰的是this指针指向的空间中的变量不能改变
//Maker *const this; 自身不可改
score = 200; //4.mutable修饰的成员变量在常函数中可以修改
cout << "score=" << score << endl;
}
public:
int id;
int age;
mutable int score; //mutable修饰的成员变量可被常函数修改
};
void test01()
{
Maker m(1, 18);
m.printMaker();
}
2.常对象
1.在数据类型前面加上const，让对象成为常对象
2.常对象可以调用常函数
3.常对象可以修改mutable修饰的成员变量
class Maker
{
public:
Maker(int id, int age)
{
this->id = id;
this->age = age;
score = 100;
}
void printMaker()const
{
cout << "score=" << score << endl;
}
void func()
{
cout << "func" << endl;
}
public:
int id;
int age;
mutable int score;
};
void test()
{
//1.在数据类型前面加上const，让对象成为常对象
const Maker m(1, 18);//常对象
//m.id = 100; //常对象不能改变普通成员变量的值
//m.func(); //常对象不能调用普通成员函数
m.printMaker(); //2.常对象可以调用常函数
m.score = 500; //常对象可以修改mutable修饰的成员变量
Maker m2(2, 20);
m2.printMaker(); //普通对象也可以调用常函数
}
07.友元（重点难点）
1.友元的概念
友元是赋予全局函数，类的成员函数，类，访问别的类的私有成员权限
注意：友元函数不是类的成员函数
1.全局友元函数
class Building
{
//声明这个全局函数为Building类的友元函数
friend void GoodGay(Building &bd);
public:
Building()
{
keting = "客厅";
woshi = "卧室";
}
public:
string keting;
private:
string woshi;
};
void GoodGay(Building &bd)
{
cout << "好基友访问:" << bd.keting << endl;
cout << "好基友访问:" << bd.woshi << endl;
}
void test01()
{
Building my;
GoodGay(my);
}
2.友元类
class Building
{
//声明GoodF类为Building类的友元类
friend class GoodF;
friend class GoodF2;
public:
Building()
{
keting = "客厅";
woshi = "卧室";
}
public:
string keting;
private:
string woshi;
};
class GoodF
{
public:
void func(Building &bd)
{
cout << "访问:" << bd.keting << endl;
cout << "访问:" << bd.woshi << endl;//通过参数访问私有成员
}
};
//1.通过传入参数来访问类的私有成员
void test01()
{
Building bd;
GoodF f;
f.func(bd);
}
//2.通过类内指针来访问类的私有成员
class GoodF2
{
public:
GoodF2()
{
cout << "无参构造" << endl;
pbu = new Building;
}
void func()
{
cout << "访问:" << pbu->keting << endl;
cout << "访问:" << pbu->woshi << endl;//通过成员指针访问私有成员
}
//拷贝构造
GoodF2(const GoodF2 &f2)
{
cout << "拷贝构造" << endl;
//1.申请空间
pbu = new Building;
}
~GoodF2()
{
cout << "析构函数" << endl;
if (pbu != NULL)
{
cout << "pbu" << endl;
delete pbu;
}
}
public:
Building *pbu;
};
void test02()
{
GoodF2 f;
f.func();
GoodF2 f2 = f;
}
3.类的友元成员函数（难点）
//1.编译器知道类的声明，不知道类的结构
class Building;//声明类
class GoodGay //声明类的结构
{
public:
void func(Building &bud);
};
class Building
{
//声明GoodGay类的成员函数func成为Building类的友元函数
friend void GoodGay::func(Building &bud);
public:
Building()
{
keting = "客厅";
woshi = "卧室";
}
public:
string keting;
private:
string woshi;
};
void GoodGay::func(Building &bud)
{
cout << "访问:" << bud.keting << endl;
cout << "访问:" << bud.woshi << endl;
}
void test()
{
Building bud;
GoodGay GF;
GF.func(bud);
}
4.友元的注意：
1．友元关系不能被继承。
2．友元关系是单向的，类A是类B的朋友，但类B不一定是类A的朋友。
3.友元关系不具有传递性。类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。
08.单例模式（重点难点）
1.单例模式是一个类只能实例化一个对象
2.实现单例模式的思路
1.把无参构造函数和拷贝构造函数私有化
2.定义一个类内的静态成员指针
3.在类外初始化时，new一个对象
4.把指针的权限设置为私有，然后提供一个静态成员函数让外面获取这个指针
//单例模式是一个类只能实例化一个对象
class Maker
{
//1.把构造函数私有化
private:
Maker()
{
}
Maker(const Maker &m)
{
}
public:
//静态成员函数，访问静态成员变量
//4.把指针的权限设置为私有，然后提供一个静态成员函数让外面获取这个指针
static Maker* getMaker()
{
return pMaker;
}
private:
//2.定义一个类内的静态成员指针
static Maker *pMaker;
};
//3.在类外初始化时，new一个对象
Maker *Maker::pMaker = new Maker;//这里可以new是因为在Maker::作用域，编译器把它当成在类内
void test()
{
//Maker m;
Maker *m = Maker::getMaker();
Maker *m2 = Maker::getMaker();
cout << "m=" << m << endl;
cout << "m2=" << m2 << endl;
//Maker m3 = *m;//调用拷贝构造，这里会产生新对象，所以要把拷贝构造也私有化
//cout << "m3=" << &m3 << endl;
}
3.单例模式案例（需求：获取打印机打印次数）
//需求，获取打印机使用的次数
class Printer
{
private:
//1.把无参构造和拷贝构造私有化
Printer()
{
mcount = 0;
}
Printer(const Printer &p)
{
}
public:
static Printer *getPrinter()
{
return p;
}
void printPrinter(string name)
{
cout << name << ":打印" << endl;
mcount++;
}
int getCount()
{
return mcount;
}
private:
int mcount;//记录打印打印的次数
//2.定义静态成员指针
static Printer *p;
};
//3.类外进行初始化，new对象
Printer *Printer::p = new Printer;
void test()
{
//销售部
Printer *p1 = Printer::getPrinter();
p1->printPrinter("销售部");
//技术部
Printer *p2 = Printer::getPrinter();
p2->printPrinter("技术部");
//公关部
Printer *p3 = Printer::getPrinter();
p3->printPrinter("公关部");
Printer *p4 = Printer::getPrinter();
cout << "打印使用的次数:"<<p4->getCount() << endl;
}