C++学习笔记（2）
C++学习笔记（2）
思维导图
浅拷贝和深拷贝：
- 浅拷贝：简单的赋值拷贝；
- 深拷贝：在堆区重新申请空间，进行拷贝；
- 浅拷贝的问题：堆区内存重复释放；
- 可以利用深拷贝解决这个问题；
深拷贝构造函数
//深拷贝的测试
class Person2
{
public :
int mAge;
int* mHeight;
Person2()
{
mAge = 0;
mHeight = 0;
cout << "无参构造的调用" << endl;
}
Person2(int age,int height)
{
cout << "有参构造的调用" << endl;
mAge = age;
mHeight = new int(height);
}
Person2(const Person2 & p)
{
cout << "深拷贝构造的调用" << endl;
this->mAge = p.mAge;
//this->mHeight = p.mHeight;//默认拷贝构造的代码，执行 浅拷贝
this->mHeight = new int(*p.mHeight);//自定义深拷贝
}
~Person2()
{
cout << "析构函数的调用" << endl;
if (mHeight != NULL)delete mHeight;//释放堆内存
mHeight = NULL;//将指针成员变量置空，防止野指针
}
};
void test12()
{
Person2 p1(22,150);
cout << "p1.mAge=" << p1.mAge << " *p1.mHeight=" << *p1.mHeight << " (int)p1.mHeight=" << (int)p1.mHeight << endl;
Person2 p2(p1);
cout << "p2.mAge=" << p2.mAge << " *p2.mHeight=" << *p2.mHeight << " (int)p2.mHeight=" << (int)p2.mHeight << endl;
}
int main()
{
test12();
system("pause");
return 1;
}运行结果
拷贝构造使用时机：
- 使用一个已经创建好的对象创建一个新对象；Person p2(p1);
- 值传递的方式给函数参数传值；void doWork(Person p){};
- 以值的方式返回局部对象；Person func(){Person p;return p;}
以值方式传递参数和返回对象，都会创建一个副本，也就是拷贝构造；
//构造函数 析构函数
class Person
{
public:
int age;
Person() { this->age = 0; };//无参构造
Person(int age) { this->age = age; };//有参构造
Person(const Person& p) { this->age = p.age; };//拷贝构造
~Person() {};//析构函数
};
//值传递的方式传参
void doWork(Person p4)
{
cout << "(int)&p4=" << (int)&p4 << " p4.age=" << p4.age << endl;
}
//值方式返回一个对象
Person doWork()
{
Person p5 = 55;
cout << "(int)&p5=" << (int)&p5 << " p5.age=" << p5.age << endl;
return p5;
}
//拷贝构造调用时机
void test11()
{
//从一个已有的对象创建一个新的对象
Person p1=11;
Person p2(p1);
cout << "(int)&p1=" << (int)&p1 << " p1.age=" << p1.age << endl;
cout << "(int)&p2=" << (int)&p2 << " p2.age=" << p2.age << endl;
//值传递的方式，将对象作为参数进行传递
Person p3 = 33;
cout << "(int)&p3=" << (int)&p3 << " p3.age=" << p3.age << endl;
doWork(p3);
//值传递的方式，返回一个对象
Person p6 = doWork();
cout << "(int)&p6=" << (int)&p6 << " p6.age=" << p6.age << endl;
}运行结果
三类构造函数：无参构造、有参构造、拷贝构造；无参构造和有参构造统称为普通构造；
三类调用方式：括号法，显示法，隐式转换法；
//构造函数
class Person
{
public:
int age;
Person() { this->age = 0; };//无参构造
Person(int age) { this->age = age; };//有参构造
Person(const Person& p) { this->age = p.age; };//拷贝构造
};
void test10()
{
//一、括号法
Person p1;
Person p2(10);
Person p3(p2);
//二、显示法
Person p4 = Person();
Person p5 = Person(20);
Person p6 = Person(p5);
//三、隐式转换法
Person p7 = 30;
Person p8 = p7;
cout << "p1.age=" << p1.age << endl;
cout << "p2.age=" << p2.age << endl;
cout << "p3.age=" << p3.age << endl;
cout << "p4.age=" << p4.age << endl;
cout << "p5.age=" << p5.age << endl;
cout << "p6.age=" << p6.age << endl;
cout << "p7.age=" << p7.age << endl;
cout << "p8.age=" << p8.age << endl;
}运行结果
仿函数（函数对象）测试
仿函数的本质并不是函数，而是重载了operator（）的类；
1、仿函数可以像普通函数那样进行调用，可以有参数和返回值；
2、仿函数超越普通函数的概念，可以拥有自己的状态（属性）
3、仿函数可以作为函数的参数进行传递
//仿函数（函数对象）测试
//仿函数的本质并不是函数，而是重载了operator（）的类；
//1、仿函数可以像普通函数那样进行调用，可以有参数和返回值；
//2、仿函数超越普通函数的概念，可以拥有自己的状态（属性）
//3、仿函数可以作为函数的参数进行传递
//有参数和返回值的仿函数
class Add
{
public:
int operator()(int a, int b)const
{
return a + b;
}
};
//有状态（属性）的仿函数
class MyPrint
{
public:
int count;
MyPrint()
{
this->count = 0;
}
void operator()(string s)
{
cout << s << endl;
count++;
}
};
//作为参数传递的仿函数
void doPrint(MyPrint &print,string s)
{
print(s);
}
void test9()
{
Add add;
cout<<"有参数和返回值的仿函数add(5, 8)=" << add(5, 8) << endl<<endl;
MyPrint print;
for (size_t i = 0; i < 5; i++)
{
print("我是有状态的 仿函数！");
cout << "仿函数调用的次数=" << print.count << endl;
}
cout << endl;
string s = "仿函数作为参数进行传递！";
doPrint(print,s);
}运行结果
C++的8种容器类的要点总结
置物之所也；
数组、链表、树、栈、队列、结合、映射表；
序列式容器：强调值的顺序，每个元素都有固定的位置；
关联式容器：二叉树，元素之间没有固定的物理顺序；
一、string字符串类compare,substr,insert,assign,=,append,+=,at,[ ],
二、vector单端数组push_back,pop_back，insert,size,capacity,resize,empty
,erase,clear,at,[ ],front,back,swap交换，收缩容量vector<int>(v).swap(v);,
reserve预留空间,
三、deque双端数组/中控器，push_front,pop_front,push_back,pop_back,
insert,begin,end,front,back,=,assign,empty,size,resize,insert,erase,clear,
at,[ ],sort,
四、stack栈容器，只有一个出入口，先进后出，栈底，栈顶top，入栈push，出栈pop，empty,size,=,不允许遍历，
五、queue队列，先进先出，一端为出口，一端为入口，不允许遍历，push，pop，front,back,empty，size，
六、list链表，内存不连续，由一系列节点组成（数据域+指针域），双向循环链表，
push_front,pop_front,push_back,pop_back,front,back,begin,end,prev,next,
assign，=，swap，empty，size，resize，inset，erase，clear，remove，
不支持（at，[ ]），不支持随机访问，reverse，sort，
- 可以快速对任意位置插入/删除元素，而无需移动其他元素;
- 动态分配内存，不会造成内存浪费和溢出；
- 空间（指针域）时间（遍历）的额外耗费比较大；
- 插入和删除操作不会造成原迭代器的失效，这在vector中不成立；
七、set集合multiset，属于关联式结构，二叉树，所有元素插入时自动排序，
set不允许有重复元素，multiset允许重复元素；
empty，size，swap，insert，erase，clear，find（返回迭代器或end），count（重复元素的个数），set插入会返回插入结果（成功或失败=重复或不重复），，
不支持（头插，头删，尾插，尾删，resize），sort，
仿函数=函数重载/运算符重载；
默认排序从小到大，可以利用仿函数改变排序规则（重载小括号（））
pair对组，默认构造，make_pair,,,,,
八、map容器，所有元素都是pair，第一个元素称为key，第二个元素称为value；
所有元素都会按照键值自动排序，本质是一个关联式容器，底层实现是二叉树；
优点：快速按照key查找元素，map不允许重复key，multimap允许重复key；
默认构造、拷贝构造、=，empty，size，swap，insert，erase，clear，
find按照key查找，返回迭代器或者end，count统计key的个数；
默认排序从小到大，可以利用仿函数改变排序规则（重载小括号（））
利用仿函数重新定义排序规则
//利用仿函数重新定义排序规则
#include<set>
//输出set容器内容，重载一
void printSet(const set<int>& s)
{
//遍历set容器并输出
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
{
cout << " " << *it;
}
cout << endl;
}
//仿函数，重新定义set集合的排序规则（从大到小）
class MyCompare
{
public:
bool operator ()(int a, int b)const
{
return a > b;
}
};
//输出set容器内容，重载二
void printSet(const set<int, MyCompare>& s)
{
//遍历set容器并输出
for (set<int, MyCompare>::iterator it = s.begin(); it != s.end(); it++)
{
cout << " " << *it;
}
cout << endl;
}
void test8()
{
//定义一个从小到大排序的set容器
set<int> set1;
for (size_t i = 0; i < 10; i++)
{
set1.insert(i);
}
printSet(set1);
//使用仿函数，定义一个从大到小排序的set容器
set<int, MyCompare>set2;
set2.insert(1);
for (size_t i = 0; i < 10; i++)
{
set2.insert(i);
}
printSet(set2);
}运行结果
vector的四种遍历方法测试
//迭代器测试iterator
void myPrint(int a)
{
cout <<&a<<" = " << a << endl;
}
void test6()
{
vector<int> v;
v.push_back(11);
v.push_back(22);
v.push_back(33);
v.push_back(44);
v.push_back(55);
//方法一
cout << "---------方法一----------------" << endl;
vector<int>::iterator begin = v.begin();
vector<int>::iterator end = v.end();
while (begin!=end)
{
cout <<"begin._Ptr="<<begin._Ptr<<" *begin=" << *begin << endl;
begin++;
}
cout << "---------方法二----------------" << endl;
//方法二
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "it._Ptr=" << it._Ptr << " *it=" << *it << endl;
}
cout << "-----------方法三--------------" << endl;
//方法三
for (size_t i = 0; i < v.size(); i++)
{
cout << "&v[i]=" << &v[i] << " v[i]=" << v[i] << endl;
}
cout << "---------方法四----------------" << endl;
//方法四
for_each(v.begin(), v.end(), myPrint);
}运行结果
vector测试
//vector测试
void test7()
{
vector<int>v;
for (size_t i = 0; i < 100; i++)
{
cout << "v.size()=" << v.size() << " v.capacity()=" << v.capacity() << " sizeof(v)=" << sizeof(v) << endl;
v.push_back(1);
}
}运行结果
迭代器
void test6()
{
vector<int> v;
v.push_back(11);
v.push_back(22);
v.push_back(33);
v.push_back(44);
v.push_back(55);
vector<int>::iterator begin = v.begin();
vector<int>::iterator end = v.end();
while (begin!=end)
{
cout <<"begin._Ptr="<<begin._Ptr<<" *begin=" << *begin << endl;
begin++;
}
}运行结果
