再学c++_2014_11_4_基础（一）

objdump -h main.0// linux下的指令，查看.o的内容

1.函数参数带默认值

int sum(int a, int b=0);          r

int sum (int a, int b)            r

{

retur a+b;

}（从右往左入栈，是为了支持可变参数）定义不能给，声明可以给默认值

2.带有默认值的函数，默认值相同不能多次声明，

int sum（int a, int b=0）;      right

int sum(int c=9, int e);         right

3.函数的重载：c:函数名前加下划线

      C++:函数名+参数

相同函数把两个参数的顺序改变一下，看是不是会报错，是错误还是重载？

{

unsig

nedint i=1；

char j=-1;

char c =i>j? 'a':'b'

}(a)

重载 覆盖 隐藏

形参会不会对实参产生影响也是区分函数是否重载的一种方式,比如用的是指针而非值传递，则不是重载

重载必须有个前提，那就是作用域

main

{

 extern sum(char*,char*s); （2）

  ...

  调用sum则永远调用（2）

}

回调方式

/*****************************c++调用c*************************************/

extern"c"

{

//以c语言的方式变异，能够找符号表，不用extern则找不到符号表  即extern是c++调用c的关键字

}

/****************************c调用c++***************************************/

g++ -shared -fPIC -o libsum.so sum.cpp 把 sum.cpp生成链接库来调用

加一个中间的动态链接库，实现c调用c++    a.so   b.h sum.c    b.so其中b.so中实现了把c语言用extern"c"调用来吧a.so的c++接口转化成c的形式,其中用到了linux的动态链接的编译。除了这种方法，就没有其他的方法了。如下：

start:

定义一个temp.cpp

------------------------------

#include "b.h"

extern"c"

{

int my_sum(int a, int b)//这是在将要生成的链接库中的函数，实际上调用的是a.so库里的函数sum(a,b)

{

    return sum(a,b);

}

}

-----------------------//生成了另一个动态链接库temp.so,到时如果调用的时候就可以通过此temp.so作为终中介来调用c++库a.so

end；

reguster 是用来定义寄存器变量的关键字

volatile：a

{

  m=a;
      example

  b=a;//每次赋值都是从a取值，不要求编译器优化做硬件用的多一点

}//如果没有volatile 关键字，编译器将会进行优化，那么每次运行到m=a和b=a的时候都是从m来赋值的，在example处加上m=i; ，则b的值将是i;但是volatile关键字却解决了这个问题，这让b=a的值是从a里取来的，即禁止编译器进行代码优化！！

32位就是一个块（32位系统）cash抓块

4.内联函数

{

 1.提高程序运行效率的一种方式

 2.更安全的一种宏！！！

 3.递归函数不能用内联展开

4.直接在调用点展开

5.内联函数一旦被展开，就不会产生内联函数的符号表，一般只会写在头文件里面，如果没有展开那另说

   {inline int sum()

{

return a+b;

}

    }int ret = sum(18,9)=18+9;   

}

5.引用和const的概念

{

 const in C

{

     const定义的变量不能用来声明数组  {const int len =21; int sum[len]={0};}

     1.常变量,但是还是变量

} 

 const in C++s//真真正正的const

{

     1.不占内存的常量，只有用到const_cast<>，&等一系列涉及地址内存的时候进行转化时才会给他分配内存

     2.预编译时候就会用具体的数字来覆盖变量名字

     3.编译阶段要确定声明数组的长度，在分离编译时，就能

     4.const变量可以定义数组

     5.const在当前文件（*.h）下替换，等到编译完毕，链接的时候，就没有了。所以外部（*.cpp）用来给整形int a赋值是不对的,因为引用的是一个不存在的东西，系统会报错。

{

*.h

{

const int b=9;

}

.cpp

{

int a=0;

a=const b;   //wrong

}

 }

     6.extern const int a;外部有人引用，a则分配内存，把他当做c语言来编译

}

const_cast<TYPE>

{

const int data=1024;

int*p=const_cast<int*>(&data)

*p=222;

cout<<data<<endl;

}

引用：

{

1.引用必须是一个有效的内存

const int &a = 10 引用的临时的变量   int &a则错误，因为 10只是一个字面常量，没有内存的

2.引用不同变量的时候则是需要加const才能通过

{

double fdata=10.24

const int &a=fdata; //引用不同变量的时候则是需要加const才能通过

}{

typedef struct

{

int data;

int a[0];

}TYPE_INT;//柔性结构体，类型是4但是实际内存却不是，sizeof(p) =TYPE_INT

TYPE_INT *p = (TYPE_INT*)malloc(sizeof(TYPE_INT)+sizeof(int)*100)

typedef struct

{

int data;

}TYPE_INT;

TYPE_INT sum(TYPE_INT a, TYPE_INT b)

{

/*未完*/2014_11_4

}

}

}

int a=10;

int b=20;

 

int *p=&a;

int &c=b;  //物理实现上就是用指针，但是不能解引用，只是别名。比指针安全多了

typedef int a[2]

{

}p;

p[2]?

int p[][2]--->p[]   int[2]   (理解intp[][2])

}