c++认识（1）

c++

比C语言多一倍的关键字

命名空间

命名冲突，自己创建的关键字与库冲突

如

namespace mysp(空间名)//命名空间域
{
int rand=0;
int a=0;
struct Node
{
int data;
}
}

int a =1;
int main()
{
int a =0;
printf("%d",a);//局部优先规则
printf("%d",::a);//::作用域符前面没限制即默认空表示全局
printf("%d",mysp::a);
struct mysp::Node node//在结构体名称前写
return 0;
}

编译默认查找顺序

1，当前局部域。2，全局域。3，展开命名空间

命名空间可以嵌套

namespace school
{
    namespace stu
    {
        string name;
    }
}
int main()
{
std::cout<<school::stu::name<<std::endl;    
return 0;
}

命名空间的使用

不同头文件可以用同一个命名空间名，在引用多个头文件后，同一空间名的会合并为一个命名空间。

using namespace std;//展开命名空间
//在大型项目展开会有冲突

展开命名空间，需要的内容可以直接使用。

但是多命名空间展开，同名会产生冲突。

三种命名空间使用方式

1.指定访问，std::cout

2.展开命名空间,using namespace std

3.对于常使用的指定展开，using std::cout

命名空间域不影响变量本身的生命周期，只是名字的隔离。

#include<iostream>

//cin,cout分别是istream，和ostream的对象
//  << 流插入,cout console控制台
// >> 流提取
//1)using namespace std;
//2)using std::endl;
//using std::cout;
#include<iostream>
int main()
{
int i=0;
double j =6.0;
cin>>i>>j;
std::cout<<i<<","<<j<<std::endl;//自动识别类型
return 0;
}

#include<iostream.h>//旧编译器

iostream头文件简接包含了C语言的头文件

#include<bits/stdc++.h>//万能头文件，但不建议使用，

缺省参数

缺省参数

//传多个参数时不能跳跃传参，且必须从右往左缺省参数
//半缺省指缺省一部分
//缺省参数默认值以声明为主；
void func1(int a=0,int b=0,int c=10){};//全缺省
void func2(int a,int b=0,int c=10){};//半缺省
void func(int a=0)//不传值使用默认参数a=0
{
cout<<"a="<<a;
}
int main(
{
func(5);
return 0;
}

应用：扩容消耗巨大，默认扩容浪费空间，使用默认扩大值有效利用空间；

重载函数(一词多义)

C语言不允许同名函数存在，c++允许在同一作用域内声明同名函数，同名函数的参数列表（参数个数，类型顺序，类型）可以不同。返回类型不同不构成重载

返回类型不同不构成重载原因func（）调用时可以有返回值也可以没有，可以接收也可以不接收，因此无法区分func（）。

函数在调用时存在隐式类型转换，可以参数类型不同时会自动转换。

不同命名空间的定义相同的函数，并不是函数重载，会发生调用歧义，

c++之所以可以支持重载是因为对函数名进行了修饰

stack.h test.cpp

预处理：展开头文件，宏替换，去注释，条件编译...

stack.i test,i编译：检查语法，生成汇编代码

stack.s test.s 汇编：把汇编代码转成二进制机器码

stack.o test .o链接：生成可执行程序.exe或a.out

call:call函数的地址，

test.cpp只有函数的声明，没有函数的地址

有函数的地址才能生成函数的一堆汇编指令，.o文件合并时对函数名进行了修饰寻找函数定义。

函数重载用修饰的函数名寻找函数，便于项目中声明和定义分离

引用（取别名）

1.作参数 2.作返回值

int main()
{
int a=0;
int &b=a;
int &c=a;
int &d=b;//本质上都是a，地址都一样
int e =2;
++d;
b=e;//不会再次引用其他变量，而只是赋值
int&&m=move(a);//诱值引用，c++11
return 0;
}

int swap（int&a，int&b)//a,b分别是c,d的别名，对a，b交换就是对c,d交换
{
int tmp=a;
a=b;
b=tmp;
}
int main()
{
int c=0,d=1;
swap(c,d);
return 0;
}

typedef struct listnode
{
int data;
struct listnode*next;
}Lsnode,*Pnode;
void pushback(Pnode& phead,int x){};
void pushback(Lsnode*&phead,int x){};//引用
void pushback(Lsnode**phead,int x){};//初版
int main()
{
return 0;}

1引用与指针的不同点

1.引用概念上为变量别名，指针储存变量地址

2.引用在定义时必须初始化，指针没有要求

3.引用在初始化引用了一个实体后，就不能引用其他实体，而指针可以在任何时候指向任何同一类型的实体

4.没有空引用，但有空指针

5.引用自加即实体自加，指针自加则指针向后偏移类型大小

6.有多级指针，无多级引用

int * ptr=NULL;
int &r=*ptr;//此时运行没有报错，并没有解引用，如图
是否报错？
cout<<r;//此时报错 

5.sizeof的含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)

-引用在底层汇编中和指针一样要开辟空间

int main()
{
const int m =1;//m只读
int &n=m;//错误，涉及权限的放大，变成可读可写
int x=1;
const int &y=x;//权限缩小，不能通过y修改值，x权限不变
int p =m;//赋值
///
const int *p1=&x;
int *p2=p;//把x的地址交给了pp，权限放大，
int *p3=&x;
const int &p4=p3;//可以，权限的缩小
return 0;
}

int main()
{//权限可以缩小，平移，不能放大
double m =3.14;
int n = m;//存在隐式类型转换，现将m的整数部分拷贝给临时变量再传给n
const int& i =m;//可以
int &j=m;//报错，因为临时变量具有常性，不能修改
return 0;
}

引用的底层也是指针

引用不能替代指针，如链表，增删查改，但引用不能改变指向。