C++
内存泄漏
用动态存储分配函数动态开辟的空间，在使用完毕后未释放，结果导致一直占据该内存单元。直到程序结束。即所谓内存泄漏。
注意：内存泄漏是指堆内存的泄漏。
简单的说就是申请了一块内存空间，使用完毕后没有释放掉。
它的一般表现方式是程序运行时间越长，占用内存越多，最终用尽全部内存，整个系统崩溃。//所以这是windows长时间不关机不好的原因之一?
由程序申请的一块内存，且没有任何一个指针指向它，那么这块内存就泄露了。
野指针
“野指针”不是NULL指针，是指向“垃圾”内存的指针。野地。
野指针的成因主要有两种：
- 指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。
- 指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。别看free和delete的名字恶狠狠的（尤其是delete），它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。通常会用语句if (p != NULL)进行防错处理。很遗憾，此时if语句起不到防错作用，因为即便p不是NULL指针，它也不指向合法的内存块。
悬挂指针
int *p = nullptr;
if (p == nullptr)
{
int c = 100;
p = &c;
}
退出if的范围之后，c变量不再存在，p指向的地址被操作系统回收了。指针被悬挂了，后续如果再被使用就会有问题。
int *p = nullptr;
{
int *q = new int
p = q;
delete q;
}
变量p指向被释放了，指针被悬挂了
memcpy-内存重叠
存在dst头部地址出现在src区域内，也就是dst前面覆盖到了src的后面，就从后往前复制。
因为如果从前往后复制的话，src的后面的值再被复制到dst前就被改写成了src的前面复制过的值了。
再考虑如果dst后面覆盖了src的前面这种情况，因为是从src复制到dst，那就从前往后复制，因为被覆盖的区域是不影响后续的复制的。
再考虑边界情况，如果dst的位置和src的位置一样，那么正常从前往后复制，dst的位置在src+len，也就是小于等于dst的位置，同理。
以下内容更详细，来自这里
内存重叠问题是指目的地址的内存空间的首地址,包含在源内存空间中,这两段内存空间有了交集,因而在使用memcpy进行内存复制操作时,这段重叠的内存空间会被破坏.这种情况在应用程序级代码中一般不会出现的,而在驱动或内核级代码中要十分小心,尽量使用memmove函数.
1.不要破坏传进来的形参，定义新的临时变量来操作
2.考虑指针的类型，不同类型的指针不能直接++赋值
3.overlap情况下需要从高地址处向前copy
void*Memcpy(void *dst, const void *src, size_t size);
int main(intargc, char *argv[])
{
char buf[100] = "abcdefghijk";
memcpy(buf+2, buf, 5);
//Memcpy(buf+2, buf, 5);
printf("%s\n", buf+2);
return 0;
}
void*Memcpy(void *dst, const void *src, size_t size)
{
char *psrc;
char *pdst;
if(NULL == dst || NULL == src)
{
return NULL;
}
if((src < dst) && (char *)src +size > (char *)dst) // 自后向前拷贝
{
psrc = (char *)src + size - 1;
pdst = (char *)dst + size - 1;
while(size--)
{
*pdst-- = *psrc--;
}
}
else
{
psrc = (char *)src;
pdst = (char *)dst;
while(size--)
{
*pdst++ = *psrc++;
}
}
return dst;
}
C中函数指针作用
1）提供调用的灵活性。设计好了一个函数框架，但是设计初期并不知道自己的函数会被如何使用。比如C的”stdlib”中声明的qsort函数，用来对数值进行排序。显然，顺序还是降序，元素谁大谁小这些问题，库程序员在编写qsort的时候不可能决定。这些问题是要在用户调用这个函数的时候才能够决定。那边qsort如何保证通用性和灵活性呢?采用的办法是让函数的使用者来制定排序规则。于是调用者应该自己设计comparator函数，传给qsort函数。这就在程序设计初期保证了灵活性。尽管使用函数指针使得程序有些难懂，但是这样的牺牲还是值得的。
2）提供封装性能。有点面向对象编程的特点。C实现面向对象编程的一种途径，大致可以实行 面向对象编程中的多态性和回调函数，
比如 设计一个栈结构
typedef struct _c_stack{
int base_size;
int point;
int * base;
int size;
int (*pop)(struct _c_stack *);
int (*push)(int,struct _c_stack *);
int (*get_top)(struct _c_stack);
}c_stack;
在初始化完之后，用户调用这个结构体上的pop函数，只需要s.pop(&s)即可。即使这个时候，工程内部有另外一个函数名字也叫pop，他们之间是不会发生名字上的冲突的。
原因很简单，因为结构体中的函数指针指向的函数名字可能是
int ugly_stupid_no_one_will_use_this_name_pop(c_stack *)
只是stack的用户是不知道他在调用s.pop(&s)，实际上起作用的是这样一个有着冗长名字的函数。
函数指针这种避免命名冲突上的额外好处对于一些库函数的编写者是很有意义的，因为库可能被很多的用户在许多不同的环境下使用，这样就能有效的避免冲突而保证库的可用性。
隐式类型转换 及其问题
以下内容摘自这里
什么是隐式转换？
众所周知，C++的基本类型中并非完全的对立，部分数据类型之间是可以进行隐式转换的。
所谓隐式转换，是指不需要用户干预，编译器私下进行的类型转换行为。很多时候用户可能都不知道进行了哪些转换。
为什么要进行隐式转换？
- C++面向对象的多态特性，通过父类的类型实现对子类的封装。
- 数值和布尔类型的转换，整数和浮点数的转换等。
- C++是一门强类型语言，类型的检查是非常严格的。如果没有类型的隐式转换，这将给程序开发者带来很多的不便。
隐式转换原则
- 基本数据类型的转换以取值范围的作为转换基础（保证精度不丢失）。 隐式转换发生在从小->大的转换中。比如从char转换为int。从int到long。
- 自定义对象 子类对象可以隐式的转换为父类对象。
隐式转换发生条件
- 混合类型的算术运算表达式中
int a = 3;
double b = 4.5;
a + b; // a将会被自动转换为double类型，转换的结果和b进行加法操作
- 不同类型的赋值操作
int a = true; (bool类型被转换为int类型)
int * ptr = null;（null被转换为int*类型）
- 函数参数传值
void func(double a);
func(1); // 1被隐式的转换为double类型1.0
- 函数返回值
double add(int a, int b)
{
return a + b;
} //运算的结果会被隐式的转换为double类型返回
以上四种情况下的隐式转换，都满足了一个基本原则：低精度 –> 高精度转换。
不满足该原则，隐式转换是不能发生的。
当然这个时候就可以使用与之相对于的显式类型转换（又称强制类型转换），使用方法如下：
double a = 2.0;
int b = (int)a;
使用强制类型转换会导致精度的损失，因此使用时务必确保你已经拥有足够的把握。
来源：https://blog.csdn.net/freshman__/article/details/100057423