c/c++复习

函数原型---> 返回值,函数名,形参列表,函数体
函数声明---> 返回值,函数名,形参列表
先声明在使用

int fun()
{}

int ret = fun() //没有retrun 返回随机值

函数先声明后定义:

形参调用函数时产生,
形参: 1, 传址调用 传地址调用
2,数组作为形参--->指针
void fun(int a[10])
void fun(int a[])-->fun
void fun(int *a)

void fun(int a[4][5])
void fun(int a[][5])
void fun(int (a*)[5])

void fun(int a[4][5][6])
void fun(int (*a)[5][6])--->指针加一跳过30个int
3 函数指针作为参数 -->回调函数
qsort,signal,sigaction, pthread_create,atexit(注册函数)

函数名:
1 不能重复
2 可以作为一个地址复给指针,
3 见名知义 不能有拼音 驼峰命名法

返回值类型:
1, 可以不写,默认为int, void类型 可以用return 提前结束函数
2 一次只能返回一个值,返回一个结构体起到返回多个值的效果
3 返回类型为函数指针类型
类型别名:
typedef unsigned int uint;
typedef int (*fun)(int*,int*);
int test(int *a, int *p);

FUN fun()
{
int (*p)(int *,int *) = test;
FUN p=test;
}
5 返回值类型为数组指针类型:
typedef int (*ARRAY)[3][4][5];
ARRAY fun()
{
static int a[3][4][5];
int (*p)[4][5] = a ;
int (*q)[3][4][5] = &a;
ARRAY m = &a;
return &a; //&a+1 跳过整个数组 a+1 跳过一个成员
}

函数体:
1 普通局部变量: 调用时自动在栈空间申请,函数返回自动释放, 不要返回局部变量的地址;
局部变量和全局变量重名,优先使用局部变量.
2 静态局部变量在京态存储区申请空间,只申请一次,每次函数调用的时候使用的是同一个变量,直到程序结束才会释放,只能在本函数中使用
3 一个函数体在没有特殊情况下最好不要超过两屏, 没有强制要求. 最好不要超过两屏
4 函数功能尽量单一,函数间的耦合型尽量降低

static 函数只能在本文件内使用
数组: 大小固定,快速访问,增删效率低
int a[10]; int *p=a; int (*p)[10] = &a;
int a[4][5]; int (*p)[5] = a;int (*p[5])

 

函数回调:

int (*p[5])[5] 数组指针数组
链表:大小不固定,访问没用数组块,增删效率高

字符串: 固定空间 可以随机读取,可以用指针
char str[] = "hello" -->6
char str[5] = "hello" -->越界
char str[5] = {'h','e','l','l','o'} --->字符串
(自己实现) strlen,strcpy,strcmp,strcat,strstr,strchr,memcpy,memset;
字符串反转,字符串反转单词不反转,atoi,整形变字符串 sprintf,scanf,
17 -->16+1 2^4+2^0 -->"10001"
17 --> 2*8^1+1*8^0 ---> "021"
17 --->1*16^1+1*16^0 --->"0x11"

结构体:可以存放多个不同类型的数据,
1 初始化, 2 深浅拷贝(将旧变量的的成员的值一次复给新变量的成员,不涉及堆空间,深拷贝涉及堆空间) 3 链表,二叉树,图
4 大小字节对齐

typedef struct Test
{
int a;
}A,*B;

A m---> struct Test m
B n---> struct Test* m

struct Test
{
int a;
}A,*B, M[10];

5 弹性结构体(变长结构体)
6 位域(控制32盏灯)
struct Test
{
int a:1;
int b:3;(7种颜色)
int c:2;(3中颜色)
int d:18;
}
sizeof(struct Test) == 4 printf("%lu\n",sizeof(struct Test)
strcut Test A;
A.a = 1;
A.d = 888; //直接赋值,不能超过标识范围

联合体 union
1 大小 2 每次只能使用一个成员变量
union Test
{
short a;
char b[2];
}
union Test t;
t.a = 0x1278;
printf("",b[0],b[1])

void fun(int cmd,union Test t)
{

}

栈:先进后出
队列: 先进先出

二叉树:
先序:根左右
中序:左根右
后序:左右根

 

linux 高级
无名管道,一块临时的内存空间,有

线程
CPU最小的调度单位为线程

同一个进程创建线程间,资源共享

OSI七层模型
应用层 产生网络流量的应用 ssh http ftp pop3
表示层 字符集 加密 压缩
会话层
传输层 tcp/udp
数据链路层
物理层

 

数据类型:
stirng 动态增长 重载了 + << .c_str();
bool true false 0为假
bool b=true;
if(b)

float a = 3.14f; 不加f 默认为double
int a(90) 等同于 int a = 90;

函数:

1 返回值类型一定要写,不写就错;
2 函数名可以相同,在函数名相同的情况下,形参列表一定不能相同--->函数重载
在编译期间就可以根据形参的不同来确定调用哪一个函数称之为静态绑定,亦陈之位静态绑定

3 函数模板,实现多态的一种, 根据具体实参的类型来产生模板函数,产生的模板函数,函数名一样,形参不一样 --> 静态多态,
//函数模板
template<typename U>
bool myless(U num1,U num2)
{
return num1<num2;
}

myless<int>(23,89);//
myless<STU>(STU(),STU());

4 内联函数 inline函数
用函数具体实现替换函数的调用语句,并不像宏一样简单的替换,而会计算实参得到结果传入进出才替换.(主要节省调用的开销)一般将频繁调用,逻辑结构比较简单:没有多重条件判断,没用循环,没用嵌套,没用递归,
也没有运算复杂的表达式；

引用: 没有独立的存储空间,内部的具体实现是一个指针,不是变量,只是作为一个变量的别名
对引用的操作,既是对所代表的表量的操作,只能作为一个变量的引用.
malloc(0) 返回一个地址
int a[32];
int (&ref)[32] = a;

int b[3][4];
int (&ref)[3][4] = b;
int (*p)[4] = b;

不能定义一个引用的数组,

数组的引用,
struct Test(){} sizeof(Test) == 1
struct Test(){int &a;int &b;} //定义一个数据类型,引用可以作为结构体的成员 每产添加一个引用,结构体会增加一个指针大小
int &a = 90; //error
const int &a =90; //ok




引用作为形参
不要返回普通局部表量的引用
动态申请空间:
new / delete
int *p = new int[1]; delete []p;

int *p = new int(1); //初始化一个变量
int (*p)[4] = new int [3][4] ; delete []p;
int (*p)[3][4] = new int[2][3][4];

struct A
{
A();
~A();
}

A *p = new A; delete p; //会调用构造函数和析够函数
A* p = (A*)malloc(sizeof(A)); free(p) //只是申请一片类大小的的一片空间,没有任何属性


class strcut 唯一区:默认公私有

特征: 封装(通过类和结构体实现,public, protected, private; 通过共用的接口来访问)
继承方式
public protected private
基类 pulic public protected private 子类
protected protected protected private
private X X X
多态,(抽象)

3 初始化 基类数据初始化---> 初始化列表
子对象初始化列表---> 初始化列表
引用,const成员变量----> 初始化列表


class A
{
public:
A(int a):m_a(a){}
~A(){}
int m_a;
};
class B:public A
{

public:
B(int a,int b):A(a),m_b(b){}
int m_b;
};

构造函数:
1,没有定义则会生成一个无参的构造函数,
2 自定了构造函数不会生成无参构造函数
3 拷贝构造函数(没有自定义会自动生成浅拷贝构造函数)
4 只要能够成重载,构造函数可以无限个
5 在构造函苏前面加explicit防止隐式类型转换;
6 自动调用
7 基类,子对象,

struct A
{
A(int a):m_a(a){}
A(){
A(90);

}

}

A a;
a.m_a ==? 是一个随机数

析够函数:
1 释放的时候自动调用
2 没有参数,不能构成重载,有且只用一个
3 析够和构造执行顺序相反
4 没有定义会自动产生

一个空的类默认产生的函数:
1 无参构造函数
2 拷贝构造函数
3 析够函数
4 赋值函数
4 &运算符

this 指针:
1 每一个普通的函数中都有一个隐藏的this指针,
2 静态函数没有this指针,
3 const成员函数的this指针变成const类名 *this不能通过改指针修改非静态成元变量
能调用const成员函数及静态成员函数
4 const 对象 只能调用const成员函数及静态函数


成员函数:
const成员函数
static成员函数
没有this指针只能调用静态成员函数,
通过类名可以直接调用
函数隐藏
在派生类中存在和基类函数原型一样的函数在派生类中调用改函数,默认调用派生类的, 可以通过类名来调用基类的成员函数
4 在类中定义的函数默认为inline函数
多继承:
多个继承,基类的初始化顺序,取决于继承顺序的先后,
菱形问题:

A
/ \
/ \
B c
解决办法: 1 通过类名来使用A的资源 2 虚继承: b虚继承A C 虚继承A 最终D真正继承A
3 动态多态:当成序运行到时选折调用那个函数

有最派生类真正继承被虚函数集成的类.
类中含有虚函数:
(1)将自动生成一张虚函数表,在类中产生一个指针指向改虚函数表,虚函数表存放虚函数的入口地址,
(2)派生类中若存在和基类虚A函数函数原型相同的函数B则B默认为虚函数.
(3)在派生类中会使用B函数的地址将虚函数表中A地址覆盖掉,奖派生类对象的地址赋给基类的指针,
(4)通过基类的指针或引用去调用函数时,会到虚函数表中找改函数的地址,
(5)但是由于该基类的虚函数地址被派生类的虚函数覆盖掉了,
(6)则得到的地址是派生类虚函数的地址,最总调用的是派生类的虚函数,从而实现多态,


由于是在运行的时候才去找函数的地址,才知道调用那个函数,所以将其称之位动态多态,编译多态,动态绑定,动态联编

将派生类对象复给基类的引用时,或则将派生类对象地址复给基类的指针
通过基类的引用或则指针去掉用虚函数时,会倒虚函数表中找改函数的地址,但是由于改基类
class AA是一个虚函数的类
{
virtual void fun(){}
};
class BB: public AA
{
void fun(){}
}
class CC: public BB
{
void fun()

}

若基类的虚函数只是为了实现多态而保存的接口,但本身的实现没有意义,可以将其声明为纯虚函数,含有纯虚函数的类不能定义对象,
继承了抽象类的派生类,若没有对纯虚函数进行重新定义,则仍然为抽型类

友元函数: 友元破坏了类的封装, 友元是单向的,不是相互的
1, 普通函数作为类的友元


运算符重载:
1,函数对象,重载()---->operator()
2,Mystring --->赋值,拷贝 ++str str++ operator[] oper ***
3 注意事项: 语法结构,操作个数, 优先级, 结构性 不能改变
.: 成员运算符
-> 成员指针
:: 作用域
sizeof 长度运算符
?: 条件运算符
# 预处理
STL:
vector
list
map
set
queue

单例模式:
懒汉模式:
class Singnal
{
public:
static
}

class singnal
{
public:
static singnal& getinstance()
{
static singnal sing;
return sing;

}
public:
singnal(){}
singnal(const singnal &sing);
};
//饿汉模式
class singnal_two
{
public:
static singnal_two& getinstance()
{ //单多线程时 会产生对new singnal_two 的争抢 所以是饿汉模式
if(NULL == sing)
{
sing = new singnal_two;
return *sing;

}

}
private:
singnal_two(){}
singnal_two(const singnal_two& sing){}
static singnal_two* sing;

};
singnal_two* singnal_two::sing= NULL;