C++基础知识整理

C语言中宏定义的理解

#define是C语言中提供的宏定义方法，其主要目的是为程序员在编程时提供一定的方便，并能在一定程度上提高程序的运行效率

有两种常用的宏定义：
（1）简单的宏定义：
#define <宏名>　　<字符串>
例： #define PI 3.1415926
（2）带参数的宏定义
#define <宏名> (<参数表>) <宏体>
例： #define A(x) x

在一个集成的开发环境如Turbo C中将编写好的源程序进行编译时，实际经过了预处理、编译、汇编和连接几个过程。其中预处理器产生编译器的输出，它实现以下的功能：
（1）文件包含
可以把源程序中的#include 扩展为文件正文，即把包含的.h文件找到并展开到#include 所在处。
（2）条件编译
预处理器根据#if和#ifdef等编译命令及其后的条件，将源程序中的某部分包含进来或排除在外，通常把排除在外的语句转换成空行。
（3）宏展开
预处理器将源程序文件中出现的对宏的引用展开成相应的宏 定义，即本文所说的#define的功能，由预处理器来完成。
（4）防止一个头文件被重复包含

优点：1、方便程序修改； 2提高程序的运行效率、

C++运行时分为哪几个区

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放。

4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放。

5、程序代码区—存放函数体的二进制代码。

C++中的 new 和C语言中的 malloc 的区别

malloc需要自己计算字节数，new会根据类型自动计算字节数
malloc返回一个空指针，需要自己进行类型转换，new 自动匹配指针类型
malloc不会自动调用类的构造函数，new会自动调用类的构造函数；
free一个对象时，不会自动调用类的构造函数，delete一个对象时会自动调用类的析构函数；
malloc,free是函数，new,delete是运算符;
new和delete:用于元素的申请
new[]和delete[]用于数组的申请；
malloc函数的原型：void *malloc(unsigned int size)

全局变量和静态变量

static全局变量与普通的全局变量有什么区别 ?

存储方式一样（都是静态存储），但是两者的作用域不同，非静态全局变量的作用域是整个源程序，在各个文件中都有效，静态全局变量只局限于一个源文件中。

static局部变量和普通局部变量有什么区别 ？

把普通局部变量改为静态后改变了生存期，生存期变长。

static函数与普通函数的区别

只在当前源文件中使用的函数应该说明为内部函数(static修饰的函数)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件.

stctic成员变量和static成员函数

-静态成员变量属于整个类所有
-静态成员变量的生命期不依赖于任何对象，为程序的生命周期
-可以通过类名直接访问公有静态成员变量
-所有对象共享类的静态成员变量
-可以通过对象名访问公有静态成员变量
-静态成员变量需要在类外单独分配空间
-静态成员变量在程序内部位于全局数据区 (Type className::VarName = value)

-静态成员函数是类的一个特殊的成员函数
-静态成员函数属于整个类所有，没有this指针
-静态成员函数只能直接访问静态成员变量和静态成员函数
-可以通过类名直接访问类的公有静态成员函数
-可以通过对象名访问类的公有静态成员函数
-定义静态成员函数，直接使用static关键字修饰即可

C++多态的概念

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。。多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是用基类的引用指向子类的对象，也可以说是同一种事物表现出的多种形态。
实现原理：
多态是指通过基类的指针或者引用，在运行时动态调用实际绑定对象函数的行为。与之相对应的编译时绑定函数称为静态绑定。多态是面向对象编程的核心思想之一，能够很有效地提高程序的可扩充性。因此我们有必要深入探索一下它的实现原理。理解了原理才能更好的使用。
示例代码：

#include <stdio.h>
#include <string>
 
#define trace(fmt, ...) printf("[trace] %s:%s:%d " fmt, __FILE__, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 
class IClient
{
	public:
		IClient(){};
		virtual ~IClient(){};
		virtual ssize_t recv(char *buff, size_t len) = 0;
};
class CStreamClient: public IClient
{
	public:
		CStreamClient(){};
		~CStreamClient(){};
		ssize_t recv(char *buff, size_t len)
		{
			trace("recv %d bytes in %p\n", len, buff);
			return len;
		}
};
int main(int argc, char **argv)
{
	CStreamClient streamclient;
	IClient &client = streamclient;
	client.recv(NULL, 0);
	return 0;
}

拥有虚函数的类都有属于自己的虚表存放在.text段中，实例化后对象拥有一个内建变量_vptr虚表指针，它指向了实际对象的虚表，通过虚表能够得到实际对象的虚函数地址。

关于mecpy函数的问题

memcpy函数的原型为：void *memcpy(void *destin, void *source, unsigned n);
如果 destin 和 source 的区域存在重叠呢？代码如下：

#include <string.h>
#include <stdio.h>
#include <iostream>

int main()
{
	char a[11] = "1234567890";
	memcpy(&a[2], a, 5);
	printf("%s", a);
	int d;
	std::cin >> d;
	return 0;
}

结果：1212345890

C++继承和派生，内部访问，外部访问

继承：保持已有类的特性来构造新类的过程称为继承
派生：在已有类的基础上新增自己的特性而产生新类的过程称为派生
内部访问：类中定义的方法访问本类中的成员变量称为内部访问，内部访问可以访问公有、私有和保护变量
外部访问：通过类的对象来直接访问对象的成员变量，只能访问公有成员变量，如 tree.leaf
继承方式分为三类，public类型， protected类型，private类型
公有继承（public）时，对基类中的公有成员和保护成员的访问属性保持不变，而对基类的私有成员则不能访问。
保护继承（protected）时，基类的公有成员和保护成员被派生类继承后变成派生类的保护成员，而基类的私有成员在派生类中不能访问。
私有继承（private）时，基类的公有成员和保护成员被派生类继承后变成派生类的私有成员，而基类的私有成员在派生类中不能访问。

C++类的三种关系，不相关、继承、复合

不相关是指两个不同的类之间没有关系，继承是指指两个类之间满足继承关系，其中 B 继承自 A 表示 B是一个A，比如女人、男人都是人， 那么女人男人就可以从人那里继承而来。复合关系是指一个类包含一个类，比如一个二维点类（point）含有 x、y 坐标，一个圆类（circle）含有一个圆心和半径，因此Circle 类应该包含 Point 类。他们之间应该是复合关系。

C++三种类型成员

public， protected， private， 默认是 private 类型

C++ 派生类成员覆盖基类成员

如果C++中派生类的成员与基类相同，会在内存中存在一份与基类同名的成员，比如:

class base {
	int j;
public:
	int i;
	void func();
};

class derived : public base{
public:
	int i;
	void access();
	void func();
};

void derived::access() {
 j = 5;	//error
 i = 5;	//引用的是派生类的i
 base::i = 5; //引用的是基类的i
 func();	//派生类的
 base::func();	//基类的
} 
derived obj;
obj.i = 1;
obj.base::i = 1;

一般不会定义同名的成员变量，会定义同名的成员函数

派生类的构造函数和析构造函数

• 构造派生类时，总是先执行基类的构造函数，再执行派生类的构造函数。基类构造函数可以显式调用或者隐式调用。
• 在析构派生类时，先执行派生类的析构函数，再自动调用基类的析构函数。基类析构函数是自动调用的。

虚函数

在类的定义中，前面有 virtual 关键字的成员函数就是虚函数，virtual 关键字只用在类定义里的函数声明中，写函数体时不用 virtual。构造函数和静态成员函数不能是虚函数。

C++引用和指针

C++引用的底层也是指针实现的，那C++为什么还需要引入引用呢？
1.引用是为了支持C++运算符重载，比如，使用引用传递参数实现运算符重载，重载后使用运算符时就成了 a = b - c ，这样与运算符的使用比较相近，但是写 a = &b - &c 就显得很奇怪。
2.使用指针经常容易犯错误：1.操作空指针，2.操作野指针，3.不知不觉地改变了指针的值
3.使用引用的特性与好处：1.不存在空引用，2.必须初始化，3.一个引用永远指向他初始化的那个对象

虚析构函数

虚析构函数存在的原因：通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数。但是，删除一个派生类的对象时，应该先调用派生类的析构函数，然后再调用基类的析构函数。
解决方法：把基类的析构函数声明为 virtual，派生类的析构函数可以不用 virtual 进行声明；通过基类的指针删除派生类对象时，首先调用派生类的析构函数，再调用基类的析构函数。

纯虚函数和抽象类

• 纯虚函数：没有函数体的虚函数，定义方式：再函数后面加 “= 0”。
• 包含纯虚函数的类叫抽象类
• 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象
• 抽象类的指针和引用可以指向抽象类派生出来的类的对象
• 在抽象类的成员函数内可以调用纯虚函数，但是在构造函数或析构函数内部不能调用纯虚函数
• 如果一个类从抽象类派生而来，那么当且仅当它实现了基类中所有的纯虚函数，它才能成为非抽象类

标准输入输出

• cin 对应于标准输入流，用于从键盘读取数据，可以被重定向为从文件中读取数据
• cout 对应标准输出流，用于向屏幕输出数据，也可以重定向为向文件写入数据
• cerr 对应于标准错误输出流，用于向屏幕输出出错信息
• clog 对应于标准错误输出刘，也用于向屏幕输出出错信息
• cerr 和 clog 的区别在于 cerr 不适用缓存区，clog使用缓存区
  例子：freopen("test.txt", "w", stdout);将标准输出重定向到 test.txt文件

函数模板和类模板

• C++提高程序可重用性有两种机制，一种机制叫做继承，另一种机制叫做泛型，使用模板的程序设计就叫做泛型程序设计。
• 函数模板：

template <class 类型参数1, class 类型参数2, ......>
返回值类型 模板名（形参表）
{
	函数体
};
template <class T>
void Swap(T & x, T & y)
{
	T temp = x;
	x = y;
	y = tmp;
}

• 编译器由模板生成函数的过程称为模板的实例化，实例化函数模板有两种方式：通过参数实例化函数模板和不通过参数实例化模板
• 通过参数类型实例化：

int a = 1;
int b = 2;
double c =3.5;
double d = 4.6;
Swap(a, b);
Swap(c, d);

• 不通过参数实例化，自行指定类型：

template <class T>
T Inc(T n)
{
	return 1 + n;
}
int main()
{
	cout << Inc<double>(4)/2; //输出 2.5
	return 0；
}

• 函数模板可以重载，只要他们的形参表或类型参数表不同即可。
• 在有多个函数和函数模板名字相同的情况下，编译器如何处理一条函数调用语句
  1）先找参数完全匹配的普通函数（非由模板实例化而得的函数）。
  2）再找参数完全匹配的模板函数。
  3）再找实参经过自动类型转换后能匹配的普通函数。
  4）上面的都找不到，则报错。
  注意：编译器在匹配模板函数时，不进行类型自动转换
• 类模板
  为了多快好省地定义出一批相似的类，可以定义类模板，然后由类模板生成不同的类
  类模板的写法：

template<class 类型参数1, class 类型参数2, ......> //类型参数表
class 类模板名
{
	成员函数和成员变量
};
可以将类型参数列表中的 class 改为 typename
template<typename 类型参数1, typename 类型参数2, ......> //类型参数表
class 类模板名
{
	成员函数和成员变量
};

类模板的用法

类模板名<真实类型参数表> 对象名（构造函数实参表）;
Pair<string, int> student("Tom", 19);

• 编译器由类模板生成类的过程叫类模板的实例化，由类模板实例化得到的类，叫模板类。同一个类模板的两个模板类是不兼容的。
• 类模板的“<类型参数表>"中可以出现非类型参数：

template <class T, int size>
class CArray{
	T array[size];
	public:
	void Print()
	{
		for(int i = 0; i < size(); i++)
			cout << array[i] << endl;
	}
};

在C++中调用C语言代码

C++中使用了 mangle 技术，对函数重载的函数名加上编译器中自定义规则的表示符，编译后同名函数的名称会不一样，C语言不支持重载，如果在C++中想要调用C语言开发的一些API，就需要使用 extern “C” 修饰函数声明。为了让C语言和C++都能够调用同一个API，可以在 extern “C” 的基础上使用条件编译。代码如下所示：

//sum.h文件声明
#ifndef __SUM_H
#define __SUM_H
 
#ifdef __cplusplus
extern "C" {
#endif
int sum(int a, int b);
#ifdef __cplusplus
}
#endif
#endif
 
//sum.c文件实现
#include "sum.h"
int sum(int a, int b) {
return a + b;
}

C++中重载和重写的区别

• 重载是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。
• 重写是指在派生类中重新对基类中的虚函数（注意是虚函数）重新实现。即函数名和参数都一样，知识函数的实现体不一样。

C++如何防止内存泄漏

• 在类的构造函数和析构函数中要匹配地使用 new/delete
• 在代码中使用 new 单个对象或者基本类型之后，要记得用 delete 清除，使用 new 创建了一个数组，比如 new int a[10]，要使用 delete[] 删除数组。
• 要将基类的析构函数定义成虚函数
• 不要手动管理内存，可以尝试在适用的情况下适用智能指针（智能指针是存储指向动态分配（堆）对象指针的类，能够在适当的时间自动删除指向的对象）。
• 在编程时尽量少用 new 和 delete，需要的动态内存时可以隐藏在 RAII 对象中。（Resource Acquisition Is Initialization，利用的就是C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象，在其构造时获取对应的资源，在对象生命期内控制对资源的访问，使之始终保持有效，最后在对象析构的时候，释放构造时获取的资源）

与Const有关的问题

常量指针和指针常量

常量指针是指向常量的指针，不能通过常量指针更改所指向变量的值；指针常量是指针值不能更改的指针，指针的值不可更改。两种指针的定义方式也不一样。

//指向常量的指针
const int a = 3;
const int * pa = &a;
int * ptra = &a;	//error!

//指针常量
int num = 0;
int * const ptr = #
ptr = ptr;		//error! ptr 的值已经不能被修改

const 与函数的用法

• 类中的 const 成员函数（常量成员函数）
  类中的常量成员函数不能修改类中的成员数据，也不能调用类中的非常量成员函数，否则编译器会报错。定义常量成员函数的方法：

class statck
{
	int num;
	int getNUm() const
	{
		return num;
	}
}

• const

C++构造函数的问题

• 在C++中注意构造函数不能调用构造函数，因为在构造函数中生成构造函数只会调用一个零时对象，零时对象会立马析构。比如如下代码：

#include<iostream>
#include<string>
using namespace std;
class Copy_construction {
public:
    Copy_construction(int a,int b,int c)
    {
        this->a = a;
        this->b = b;
        this->c = c;
        cout << "这是Copy_constructiond的有3个默认参数的构造函数!  "<<this->a<<" "<<this->b<<" "<<this->c<<endl;
    }

    Copy_construction(int a, int b)
    {
        this-> a= a;
        this->b = b;
        Copy_construction(3, 4, 5);
        cout << "这是Copy_constructiond的有2个默认参数的构造函数!  " << this->a << " " << this->b << endl;
    }
    ~Copy_construction()
    {
        cout << "Copy_construction对象被析构了！ "<<this->a << " " << this->b << " " << this->c << endl;
    }

    int getC()
    {
        return c;
    }
private:
    int a;
    int b;
    int c;

};


int run()
{
    Copy_construction aa(1, 2);
    cout << aa.getC() << endl; //c的值为垃圾值，因为匿名对象被创建有立即析构了                                  //就算用不析构的方式，也是垃圾值，因为c是不同对象中的元素　　　　　　　　　　　　　　　　　　　　//在2个参数的构造函数中，没有显式初始化c，不能通过构造其他对象而在本构造对象中访问未初始化的数据
    return 0;
}
int main()
{

    run();
    cout << "hello world!\n";
    return 0;
}

结果：
可以看出，在参数较多的构造函数中，不能简单的采用参数较少的构造函数来简化流程。
但是目前有两种办法：
1）采用 placement new 技术，new(this) Copy_construction(a, b); this->c = c;
2）类似于派生类构造函数调用基类构造函数:

Copy_construction(a, b, c) : Copy_construction(a, b)
{
	this->c = c;
}

不过这依赖于编译器的实现。
最稳妥的办法还是采用每个构造函数都写一遍，多点代码量罢了。