函数的重载，c和c++的互调，c和c++的区别2

函数重载

bool compare(int a,int b)
bool compare(char a,char b)

这里是引用

c++生成函数符号依赖函数名和参数列表（返回值不影响）
c语言依靠函数名
函数名相同，参数列表不同为函数重载
函数重载是在编译期决定使用那个函数----------静多态（编译时期的多态）
类型的转换：
double ------------------------------------------------------ float
unsigned
long
int ----------------------------------------------------------------char short
从下到上转换，从右向左转换（无条件转换）
c和c++相互调用

extern "C"使用C语言的方式编译下面的代码
{
void fun_c();.c文件中的函数
}这样c++可调用c的函数

如果不使用extern，将通过c++的方式生成符号。
c语言调用c++，让C++自己将函数以c的方式调用，然后让c使用

//.c文件
namespace AA
{
    typedef int INT;
    typename char CHAR;
}；
//.cpp文件
#include<iostream>
#include".c文件名"
using namespace AA;
使用该AA空间才可以在.cpp文件中使用AA中的定义
还有一种使用方式using AA::INT;只拿出来这一个定义

指针和数组名的区别：

//.c文件
int arr[]={0,1,2,3,4,5,7,8};
//.cpp文件中
extern int* arr;把常量当作指针（变量）来引用
cout<<arr<<endl;结果为0
cout<<*arr<<endl;崩溃
cout<<arr[0]<<endl;

每次cout都是对该变量的解引用，去该变量的地址里取值

int a=10;
int* p=&a;
int arr1[]={0,1,2,3,4,5};
cout<<arr1<<endl;结果为地址
cout<<p<<endl;结果为地址

数组名–地址------常量
指针------变量

//.c文件
int main()
{
  const int a=10;C语言无法定义常量，这样定义的用指针指向它还是可以改变他的值，这种定义叫做常变量，只要a不是左值
  int* p=&a;
  *p=20;
  printf("%d",a);结果是20；
}


//.cpp文件
const int a=10;常量：在编译时期将常量的值直接写入到常量的使用点，所以常量必须初始化。 常量占内存
a=20;错误，不能为左值
int* p=&a;错误
int* p=(int*)&a;正确，这里生成了一个临时量
cout<<a;//10
cout<<*p;//10
*p=20;
cout<<a;//10
cout<<*p;//20

const int a=10;
const int b=a;正确，用常量初始化常量
int d=10;
const int c=d;，d只有在运行时才能拿到值，而c在编译时就得将值放入，因此该变量会退化为常变量


int a=10;
int *p1=&a;
const int* p2=&a;
int const* p3=&a;
int* const p4=&a;

int *q1=&a;
const int* q2=&a;
int const* q3=&a;
int* const q4=&a;


p1=q1;正确
p1=q2;错误，泄露常量的地址给非常量指针
p1=q3;错误，同上
p1=q4;正确

p2=q1;正确
p2=q2;正确
p2=q3;正确
p2=q4;正确

p3=q1;正确//
p3=q2;正确
p3=q3;正确
p3=q4;正确


p4=q1;错误
p4=q2;错误
p4=q3;错误
p4=q4;错误，p4不能作为左值

const和指针：
const修饰的内容不能作为左值
不能泄露常量的地址给非常量的指针
const修饰的类型是离他最近的第一个成型类型，其他修饰的是内容
参数加const如果不包含指针不能形成重载，只有类型不同才能重载

int fun(int a);
int fun(const int a)这两个不能构成重载
int fun(const int* a);
int fun(int *a)这两个重载

引用：从汇编代码来看，引用是和指针一样，引用的底层就是指针，在使用引用的地方，在编译时会自动替换为指针的解引用

int a=10;
int& b=a;
b=20;
int* p=&a
cout<<a;20
cout<<b;20

引用为什么必须初始化？在使用到引用的地方，在编译时会自动替换为指针的解引用，因此，引用一旦初始化就无法改变解引用的方向

int fun1()
{
return 10;
}
const int&e=fun1();返回值接受时必须加const
const int& f=10;10无法取地址，用const可以
当引用一个不可以取地址的量的时候，使用常引用
工作过程，会生成一个临时量，真正引用的是临时量，因为临时量都有常属性，所以得加const

动态内存：
C语言 malloc free
c++ new delete

int* p=new int;
*p=10;
delete p;
ibt *arr=new int[10];
delete[]arr;

使用malloc和free申请释放一维数组和二维数组
int** arr=new int*[4];
for(int i=0;i<4;++i)
{
arr1[i]=new int[5];
}
for(int i=0;i<4;++i)
{
delete[]arr1[i];
}
delete[]arr1;