c++总结

c++ primer终于看完了 感觉更多的是一本工具书，有些地方理解的还不够，遇到了再加深下理解
剩下的就不去找书看了时间不够了，再去看些内存布局，对象模型，以及一些重要的stl源码
一些面试笔试中关于c++的题也会写在这里，接下来看cs：app这本书吧，任重而道远 加油
明天开始一天一个公司的面经吧（现在就看c++，算法，linux方面的题，还有操作系统吧，操作系统的看完csapp应该没有时间看别的书了）

1.c++中的static和const
博文地址：
https://www.cnblogs.com/retry/p/9509403.html
const：
const是定义一个常量的意思，就是一个只读的不可修改的意思，但是有一种情况例外，当用作类的数据成员时
我们声明并初始化了一个const int mx = 100；我们还可以用构造函数的初始化列表去改变
例：

#include 
#include 
#include 
#include 
#include 
#include "db3.cpp"
using namespace std;
class fuck
{
public:
	fuck(int i):x(i){};
	void p()
	{
		cout<

另外就是顶层const 底层const之分了，还有我们可以修饰一个成员函数，用const这样常量对象就能访问这个函数

static：
修饰一个对象为静态对象，存放在全局储存区中，内置变量的修饰就没什么好说的了，对于类成员的修饰：
当一个数据成员非const时，我们只能在类内声明，类外定义，并且目的一般都是共享内容，可以通过类名访问也可以通过对象名访问，当修饰成员函数时，只能访问static成员；类大小： static 成员类外存储，求类大小，并不包含在内;

2.手写memcpy
https://blog.csdn.net/sszgg2006/article/details/7989404
注意内存重叠即可：

 
#include 
#include 
#include 
#include 
#include 
#include "db3.cpp"
#include
using namespace std;
class fuck
{
public:
	fuck(int i):x(i){};
	void p()
	{
		cout<(d);
		char * ss = static_cast(s);
		while(conut--){
			*dd = *ss;
			dd++;
			ss++;
		}
	}
	else{
		char * dd = static_cast(d+conut-1);
		char * ss = static_cast(s+conut-1);
		while(conut--){
			*dd = *ss;
			dd--;
			ss--;
		}
	}
	return d;
}
int main()
{
	char s[50] = "fwfsgsgsa";
	char ss[50] = "aaaa";
	cout<

3:内联函数和宏定义函数

	http://www.cnblogs.com/P3nguin/p/7977860.html

宏定义函数：是直接替换，所以最好全部打上括号，例如
#define add(a+b) a+b
printf("%d",5*add(3,6)) 输出15+6=21
所以最好这样定义 add(a,b) ((a)+(b))

内联函数与宏定义函数的区别：
https://blog.csdn.net/qq_33774935/article/details/52382140
主要区别：
1：内联函数在编译时插入代码中，是编译器干的事，而宏定义函数是在预处理阶段替换的变量
2：内联函数要做类型检查，而宏定义函数不用

1.内联函数在运行时可调试，而宏定义不可以;
2.编译器会对内联函数的参数类型做安全检查或自动类型转换（同普通函数），而宏定
义则不会；
3.内联函数可以访问类的成员变量，宏定义则不能；
4.在类中声明同时定义的成员函数，自动转化为内联函数。

4:重载，覆盖，隐藏

重载：1：相同作用域内
2：同名函数，参数不同
3：virtual有没有无所谓
覆盖：1：不同作用域，通常是指基类和派生类
2：函数名相同，参数相同
3：基类函数必须有virtual
隐藏：1：不同作用域
2：函数名相同
1) 参数不同，不管基类是不是有virtual
2) 参数相同，基类必须不是virtual

#include
using namespace std;
 
class Base
{
public:
    virtual int foo(int x)
    {
        return x * 10;
    }
 
    int foo(char x[14])  //重载
    {
    	//x是一个指针，在32位上所以sizeof是4
        return sizeof(x) + 10;
    }
};
 
class Derived: public Base
{
    int foo(int x)   覆盖Base:: foo（int）;
    {
        return x * 20;
    }
 
    virtual int foo(char x[10]) 重载foo
    {
        return sizeof(x) + 20;
    }
} ;
 
int main()
{
    Derived stDerived;
    Base *pstBase = &stDerived;
 
    char x[10];
    printf("%d\n", pstBase->foo(100) + pstBase->foo(x));
 
    return 0;
}

5：重载a++，++a

#include 
#include 
#include 
#include 
#include 
#include "db3.cpp"
#include
using namespace std;
class fuck
{
public:
	int a=1;
	fuck& operator++(){
		++a;
		return *this;
	}
	fuck operator++(int)
	{
		fuck t = *this;
		++*this;
		return t;
	}
};
int main()
{
	fuck c;
	c++;
	++c;
}

6:union
https://blog.csdn.net/xiajun07061225/article/details/7295355
union申请的内存空间为最大的成员，所有成员共享同一个地址，某一时刻只有一个成员的值是有效的

7 动态链接库和静态链接库的区别

https://www.cnblogs.com/king-lps/p/7757919.html
感觉这个应该放在linux里面阿
库有两种：静态库（.a、.lib）和动态库（.so、.dll）。 windows上对应的是.lib .dll linux上对应的是.a .so
我们知道一个cpp文件运行起来最后一个步骤是链接阶段，两者区别就在于对库的处理方式
静态链接库是在编译时期，将整个库都一起放进可执行文件中，这样做无疑很耗内存
而动态链接库则是记录库在哪个文件中，以及在文件的哪个位置，在运行时才调用该库
顺便说下linux下生成可执行文件的过程：
源文件 db.cpp
预处理: g++ -E db.cpp -o db.i
（编译阶段，负责检查有没有语法错误这些）生成汇编代码：g++ -S db.i -o db.s
汇编阶段（生成目标文件) g++ -c db.s -o db.o
链接阶段（链接各种库)： g++ db.o -o db.