C++学习问题
内容原创，未经本人同意请勿转载。联系本人：[email protected]
1，virtual函数
函数之前加上virtual关键字就表示该函数为虚函数，在派生类中通过重写该虚函数来实现对基类函数的覆盖。
//基类中定义virtual函数
class base
{
public:
virtual void fun() {cout<<"BASE";}
};
//派生类中覆盖fun函数
class derived: base
{
public:
//不管该函数之前是否添加virtual字段，该函数都是虚函数
void fun() {cout<<"DERIVED";}
};
/*多态使用*/
int main()
{
base* d = new derived();
/*类的多态，调用的是派生类中的fun函数*/
d->fun();
}
//输出
DERIVED
//
void call_fun(base* b)
{
//如果b是base类的实例，就调用base中的fun
//如果b是derived类的实例，就调用derived中的fun
b->fun();
}
为何"虚"---动态联编
virtual函数用到了动态联编和推迟联编的技术，virtual函数在编译的时候是无法确定的，而是在运行的时候被确定的。
编译器在发现类中有virtual函数的时候，就会为该类分配一个VTABLE函数指针数组，这个数组里存放了类中的所有虚函数。
一个类只有一个VTABLE，不管有多少个实例
派生类有各自的VTABLE
同一个虚函数在基类和派生类的VTABLE的相同位置
编译器在编译的时候为每个实例在内存中分配一个vptr字段，该字段指向本实例的VTABLE
void call_fun(base* b)
{
//如果b是base类的实例，就调用base中的fun
//如果b是derived类的实例，就调用derived中的fun
//编译后该函数b->fun();变成
(base->vptr[1])();
//这样根据传递进来的实例不同，就调用不同的函数。
}
纯虚函数(interface类)
class base
{
public:
virtual fun() = 0; //0标志一个虚函数为纯虚函数
}
纯虚函数表示该类是一个抽象类，无法被实例化，只能被派生类继承覆盖。用来规范派生类，这就是所谓的“接口”类，用来约束派生类需要实现这些函数。
为什么有的析构函数必须写成虚函数
派生类的构造和析构函数的正常执行流程
- 创建派生类，先执行基类的构造函数，再执行派生类的构造函数
- 销毁派生类，先执行派生类的构造函数，再执行基类的构造函数
#include
using namespace std;
class base
{
public:
base(){cout<<"base structure"< 派生类的构造和析构函数的异常执行流程
将main函数中的ps换成基类类型(多态特性)，看看会有什么结果
int main()
{
base* ps = new sub();
count<<" "<上面的代码改过后，发现释放的时候，只调用了基类的析构函数。但是构造的时候基类、派生类构造函数都被调用了。这就引发了内存泄露的问题。
总结： 如果要用基类类型操作派生类，必须将析构函数写成
virtual函数，否则会造成析构一半，从而出现内存泄漏。
基类操作的正常析构虚函数
#include
using namespace std;
class base
{
public:
base(){cout<<"base structure"< 上面的代码只是在基类的析构函数~base()前加了virtual ~base()，在释放的时候，就能正常析构了。想想virtual函数的精髓，不难理解由于C++的多态特性，ps虽然是base类型，但是它由sub构造而成，所以析构的时候还是调用sub提供的析构函数。
2，命令空间
定义
namespace ns1
{
int a;
int b;
class base{};
void fun(){}
}
分离式定义
one.h
#ifndef TWO_H_
#define TWO_H_
namespace two
{
void say();
}
#endif
two.h
#ifndef TWO_H_
#define TWO_H_
namespace two
{
void say();
};
#endif
one_two.cpp
#include
#include "one.h"
#include "two.h"
void one::say()
{
cout<<"one say\r\n";
}
void two::say()
{
cout<<"two say\r\n";
}
//如果声明的空间有类如何实现？？？？
使用
若想使用某个标识符，using 空间名::标识符;
若想使用改namespace下的所有标识符 using namespace 空间名;
//方法1
using namespace one;
//方法2
using one::say;
自定义空间名使用
#include
#include
using namespace std;
using namespace one;
using namespace two;
//全局函数
void say()
{
cout<<"global say\r\n";
}
int main()
{
//全局函数，一定要加上::
//否则会出现 错误：调用重载的‘say()’有歧义
::say();
one::say();
two::say();
}
3，模板
模板可以实现逻辑相同，但是数据类型不同的代码复制。当用户使用模板时，参数由编译器决定，这很像宏。
模板分为函数模板和类模板。
函数模板
定义&使用
template <类型参数表> 返回类型 函数名(形参列表) {函数实体}
template void print(const T& var)
{
cout< T min(T ii, T jj, T kk)
{
T temp;
if(ii < jj) temp = ii;
else temp = jj;
if(temp > kk) temp = kk;
return temp;
}
int main()
{
int minNum = min(100, 30, 102);
cout< 类模板
定义和使用
templete <类型参数列表> class base{};
4，操作符重载
4.1，怎么定义该函数
使用operator xx（xx表示操作符，例如==，+，-，等）
class person{
private:
int age;
public:
person(int a):age(a){};
inline operator == (const person& p) const;
};
inline person::operator==(const person& p) const
{
if(this->age == p.age)
{
return true;
}
else
{
return false;
}
}
using namespace std;
void main()
{
person p1(10);
person p2(20);
if(p1 == p2)
{
cout<<"the age equal"<4.2，为什么要重载
对于系统的所有操作符，一般情况下，只支持基本数据类型和标准库中提供的class，对于用户自己定义的class，如果想支持基本操作，比如比较大小，判断是否相等，等等，则需要用户自己来定义关于这个操作符的具体实现。比如，判断两个人是否一样大，我们默认的规则是按照其年龄来比较，所以，在设计person 这个class的时候，我们需要考虑操作符==，而且，根据刚才的分析，比较的依据应该是age。那么为什么叫重载呢？这是因为，在编译器实现的时候，已经为我们提供了这个操作符的基本数据类型实现版本，但是现在他的操作数变成了用户定义的数据类型class，所以，需要用户自己来提供该参数版本的实现。
4.3，操作符重载为全局函数
估计没人会这么使用
对于全局的操作符重载函数，左操作数的参数必须被显式的定义。
bool operator == (person const &p1, person const &p2);
如何决定使用全局还是类操作符重载函数呢？
- 1 左操作符和比较对象是不是同一个类型
- 2 C++要求，=、[]、()、->、必须定义为类操作符重载函数
5，重载函数
5.1 什么叫重载函数？
在同一个作用域内，可以有一组具有名字相同，参数不同的一组函数。重载函数用来命名一组功能相似的函数。
5.2 为什么要用重载函数
- 必须写很多函数名，来完成功能相似的一组函数
- 类构造函数，如果没有重载。那如果要实例化不同的类是比较麻烦的。
- 操作符重载本身也是函数重载，丰富了已有操作符的功能。
5.3 编译器如何解决命名冲突
编译器会把不同参数名字相同的函数，用新的函数名取代。恩，其实也就还是不同名字，但是写起来方便很多
5.4 重写函数(override)
子类重新定义父类中有相同名称、相同参数的虚函数。
- 被重新定义的函数不能为static函数
- 重写的函数一定要完全相同(包括返回值、参数)
- 重写的函数可以有不同的修饰符，例如在基类中是private，派生类可以写成public、protected
5.5 重定义函数(redefining)
子类重新定义父类中具有相同名字的函数(参数列表可以不同)。
6，static类
6.1 static成员函数
static数据成员是存储在程序的静态存储区，而并不是在栈空间上。独立于任何类的对象。
注意：static成员函数
- 没有this指针。因为static成员函数不是任何对象的组成部分
- 不能声明为const类型，不能访问非static成员，也不能访问static const成员。
6.2 static成员
注意：在类中不能对static成员进行初始化，除非写成
const static。
class person{
private:
static int age;
//static int age= 20; //错误：ISO C++ 不允许在类内初始化非常量静态成员'person::age'
const static int c_int = 100; //允许
static string name;
public:
void print()
{
cout<<"name: "<6.3 static和const不能同时修饰一个成员函数
因为static是属于类的，而const函数是为了保证改函数不会修改对象中的成员。两个关键字作用的对象不一致，所以不能放到一起使用。
内容原创，未经本人同意请勿转载。联系本人：[email protected]
7，引用
引用就相当于给一个变量取了另外一个名字(alias)，对应操作和直接操作原变量效果是一样的。
- 声明一个引用时一定要进行初始化
- 引用本身不占用内存，系统也不会给引用分配地址
7.1 引用和指针在函数参数的区别
相同点
使用指针和引用传递参数，对于运算效果来说一样的。所有对形参的操作都会直接反映到原变量当中。
不同点
指针作为形参时，函数需要给形参分配地址。而且操作中需要经常用到*指针变量的方式进行运算，代码可读性比较差。
形参作为形参时，函数在内存中并没有产生额外的地址，而是对实参直接操作。
//常量引用
int a = 100;
const int &ra = a;
//错误，常量引用不允许赋值操作
ra = 1;
//正确
a = 1;
7.2 引用作为函数返回值
网上的一些说法
-
- 不能返回局部变量的引用（函数执行完，内存就会被释放）
-
- 不能返回new出来的数据（虽然内存还在，但是会造成无法通过delete释放引用的问题）
对这个说法有点怀疑，自己实际测试结果
- 测试一，局部变量的引用返回给另外一个引用
int* & ref_pointer(const int* b)
{
int* pI = (int*)malloc(100);
cout<<"pointer addr = "< class base{};
class deliverd : public base{}; //public继承
11， 重载和覆盖
12， new delete
12.1 和malloc、free有何区别
和malloc，free一样是用来动态分配内存的，不同的是new和delete会自动调用对象的构造和析构函数。
12.2 new[], delete[]
没错这个是针对数组的操作，delete操作只会调用一次析构函数，而delete[]会调用每个成员的析构函数。一般new[]和delete[]配对使用。
13， const成员函数
若将成员成员函数声明为const，则该函数不允许修改类的数据成员
1）const成员函数可以访问非const对象的非const数据成员、const数据成员，也可以访问const对象内的所有数据成员；
2）非const成员函数可以访问非const对象的非const数据成员、const数据成员，但不可以访问const对象的任意数据成员；
3）作为一种良好的编程风格，在声明一个成员函数时，若该成员函数并不对数据成员进行修改操作，应尽可能将该成员函数声明为const 成员函数。