以下为个人总结，难免出错，不吝赐教

1） UTF-8编码:一个英文字符等于一个字节，一个中文(含繁体)等于三个字节。

2） Unicode编码:一个英文或一个中文（含繁体）都等于两个字节，介绍的很详细 // https://www.zhihu.com/question/23374078

3） 1个字节等于8位，一个int是4字节或2个字节与操作系统有关，8086只能处理16位字长，80286以上好像是32位以上了~

4）引用的作用：1.提高函数传参效率，避免不必要的复制;2.取地址 3.一般与const搭配，保护原有参数的安全，不被修改。4若做函参就不能引用为空

5）当函数返回一个对象时。可能会调用copyConstructor拷贝构造函数，明白它的原理就行，在先前预留出来的 sizof(对象)个字节的那一小块存储里建立一个临时的、匿名的对象，调不调用copyConstructor,这个视编译器而定，像我测试了一下MinGW的,只调用一次构造，没有调用copy Constructor,难道这就是自带move Constuctor??，用MSVC6.0，就像说的第一种调用Constructor 再调用copy Constructor！

6） const 数据成员只能用初始化表的形式进行初始化，也就是写在构造函数的屁股后面，另外const可作为重载的依据

7）当类成员是引用时为什么构造函数形参必须是引用如：class Test{ int& n;public:Test(int& i):n(i){ } };

8） STL有6大组成 adapters 适配器,allocators 分配内存啊释放等,algorithms 算法相关的库,containers 容器,function object 作用目标，我理解为作用对象的选择性, iterators 迭代器

9）在构造函数和析构函数中调用虚函数时，采用静态联编，即所调用的虚函数是基类中定义的虚函数，不是在派生类中重载的虚函数

10）调用对象的方法其实是调用指针指向该对象的偏移量！在编译的时候就确定了类中的方法在类的相对位置~

11）简述数组与指针的区别? 数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。

(1)修改内容上的区别

        char a[10] = “hello”; //a就代表hello的头指针，不可更改！！
        a[0] = ‘X’;
        char *p = “world”; // 注意p 指向常量字符串,p指向'w'，指针可更改 你相访问哪个字符都可以，但不能修改
        p[1] = ‘X’; // 编译器不能发现该错误，运行时错误 因为world在常量区，不能更改。p[1]表示的就是p指针向后偏移量为1，编译时转换成*(p+1),即p+1再取指针下的的值;

(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量

12） malloc返回的是void 所有要强制转换啊,new 返回的是分配的对象

13） TCP会经历三次握手：一个完整的三次握手也就是请求—应答—再次确认！！！四次挥手：请求–应答–应答–再次确认

14）为什么回溯算法可能导致系统用栈过多呢？因为回溯都是经过进栈操作，而没有出栈操作！！汇编中进栈与出栈数据宽度相同才行~

15）纯虚函数声明后时: 函数=0;

16） private继承将会把父亲所有的都变成private:若再继承一次，爷爷的所有方法，孙子都不能用了~ 而protected继承将所有public变成 protected.

17） auto_ptr 即是一种常见的智能指针,调用析构函数的时候智能指针会删除对象

18）傻傻分不清楚的指针数组与数组指针：

    指针数组：是一个数组里面全部都是指针
        例：int* p[10];因为[]优先级高先与左边结合，int即与*结合，代表数组类型是Int*
    数组指针：就是一个数组的首地址即指针，主要用于二维数组吧
        例：int(*p)[10];即是p就是指向二维数组的首地址，该数组宽度为10;

19）虚析构函数作用：在实现多态时，当用基类操作派生类，在析构时防止只析构基类而不析构派生类的状况发生

20） void * operator new (unsigned int size){} 用于重载new ，用于只能分配在栈上，不能分配在堆上，要分配在堆上就可以直接把类构造设成private:就好

21） memset();这个函数，使用要小心！一般是对数组等设置初始值为0而使用的！，他会将内存中的每一个字节（Byte）都设置为你指定的值。sizeof()也正是返回的字节总数

22） decltype是C++11出来的东西,是声明类型的意思，泛型编程中结合auto，用于追踪函数的返回值类型，例如：

template <typename _Tx, typename _Ty>
auto multiply(_Tx x, _Ty y)->decltype(_Tx*_Ty)//反正是这种用法
{
    return x*y;
}

23) float x与0比较，if(x>=0.000001 && x<=-0.000001)（x不为0的比较）

24) 多用+=或=，少用+，如CString，会产生临时对象

25) new比栈上分配要慢点，new的话系统要考虑临界区，多线程互斥等，实在要用new，又要效率高，考虑考虑内存池模型方法

26) 类模版的偏特化，少见多怪如

template <typename T, typename Allocator> class vec 
{ 
// … //
};

template <typename Allocator> class vec<int, Allocator>
{
 //…//
};//该类就是偏特化类了,int就是偏特化的值，所以只用一个参就好

2７) 别忘了 &,|,^

　 101010     101010 　　  101010
与&011100 或| 011100 异或^ 011100
  --------　  --------    -------
　 001000　　  111110　　   110110

28) 三维数组动态分配，int*a=new int [10]先分配10个连接长度的指针的指针，再分配其余的，二维亦是如此

//三维数组动态分配
int i,j,k;   //p[2][3][4]
char ***p = (char***)malloc(2* sizeof(char**));   
for(i=0; i<2; i++)   
{     
     p[i] = (char**)malloc(3*sizeof(char*));   
     for(j=0; j<3; j++)   
   {   
       p[i][j] = (char*)malloc(4*sizeof(char));   
   }
}
//二维数组//[10][9]
int **p=new int* [10];
for(int i=0;i<10;i++)
p[i]=new int[9];

//or这样的二维数组
int (*p)[9]=new int [10][9];

29) MinGW竟然不支持C++11的移动拷贝构造

30) int & operator++（）与int operator++(int)

int & operator++()前缀++ ，即俗气的++i，返回i+1
int operator++(int)后缀++，同样俗气的i++，i+=1并返回旧值

31) #pragma pack(1) 对齐方式

struct sample 
{ 
char a; 
double b; 
};

若不用: #pragma pack(1)和#pragma pack()括起来，则sample按编译器默认方式对齐（成员中size最大的那个）。即按8字节（double）对齐，则sizeof(sample)==16.成员char a占了8个字节（其中7个是空字节）。

若用: #pragma pack(1)，则sample按1字节方式对齐sizeof(sample)＝＝9.（无空字节）

32) 函数之复杂声明

int (*(*ptr)(int *))[5];
可以这样分解：
typedef  int (*PARA)[5];
typedef PARA (*ptr)(int *);

33) VS2015的CString转 const char*

思路：CString 转CStringA 转string 再转 const char*

CString str = _("socket");  
CStringA strA(str.GetBuffer(0));  
str.ReleaseBuffer();  
string s = strA.GetBuffer(0);  
const char* pc = s.c_str();

34) 虚表的初始化是在完成基类之后

35) static_cast 与dynamic_cast区别

它们都是编译期确定下来的。
1，static_cast 不能直接在没有继承关系的对象指针之间进行转换，
2，dynamic_cast 是安全的向父向子转，dynamic_cast使用必须要用虚函数,虚表第一项的type_info信息用于判断是否子类父类关系等。

36) 左移右移问题

byte a=0x3a;
printf("%d",(short)a<<8);//并不会改变a的值，只是改变接收值
printf("%d",0x3a<<8);//也可以

37) 10进制转16进制

#include <stdlib.h>

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    int m, n;
    char buf[80];

    cin>>m;
    while(m--)
    {
        cin>>n;

        itoa(n, buf, 16);//转换为是小写16进制，

        transform(buf, buf + strlen(buf), buf, toupper);//转大写

        cout<<buf <<"H" <<endl;
    }

    return 0;
}

38) 枚举占一个字节，新特性

enum AA:unsigned char {ENUM_1,ENUM_2};

39) <<与>>特别用法

举个例子：对于左移

27*8，27*4，27*2
27<<3，27<<2，27<<1
同样对于右移
27/8，27/4，27/2
27>>3，27>>2，27>>1
意思是对于剩除2*n次方，可以使用左移右移来优化，但估计现在的编译器都足够聪明了吧。。
一个高级一点的，127*1032怎么通过左右移还实现127*1033呢？
1032可以写成 1024+8+1;
127<<10+127<<3+127。。如此简单~

40) decltype(auto) 返回值加()

decltype(auto) Get()
{
    int x=0;
    return x;
    return (x);//这两种返回意思是不一样的，可用typeid().name()来验证
}

41) auto与stl的锅

vector<bool> Get()
{
    return vector<bool>(5,1);
}
int main()
{
    auto re= Get()[4];
    cout << re;
    return 0;
    //哈哈，怎么运行就蹦了？试试把auto换bool
    //原理是auto变成了悬指针，[]的锅
}

42) template的一个细节问题

如何实现像shared_ptr的自定义delete函数呢？

template<typename T>
class Human {
public:
    Human(T t) noexcept{}

    template<typename T2>
    Human(T *t, T2 t2){t2(t);}
};

int main()
{
    auto del = [&](int*p) {
        delete p; 
        cout << "deleter"<<endl;
    };
    Human<int> h2(new int(5), del);
    //似乎成功了
}

43) std::function的使用

方法1：
std::function<void (YUIObject*)> func = std::bind(&YUIObject::OnMouseLClicked,pObj,std::placeholders::_1);
方法2：
auto func = std::bind(&YUIObject::OnMouseLClicked,pObj,std::placeholders::_1);
也就是说function可以不知道相关推导信息。

44) 16进制与2进制转换

这个超级简单，
如:

80->1000 0000
33->0011 0011
25->0010 0101

扫描二维码关注公众号，回复： 2900655 查看本文章

顺手就写出了，方法然尔就是直接把16进制的每一位对应4位，例8转2进制就直接 1000，0转2还是0000，so that’s fucking easy!

45) Qt5 常量中有换行符

使用QStringLiteral宏

更多文章：http://blog.csdn.net/what951006?viewmode=list
powered by:小乌龟在大乌龟背上~

C/C++ 易忽略知识~持续记录