C++_缺省参数&重载&引用&命名空间

C++

1.在C语言中函数默认返回int类型，C++默认返回viod

2.在C语言中，函数没有指定参数列表，默认可以接收多个参数，在C++中因为有严格的参数类型检测，没有指定参数列表，默认为void，不接受任何参数

3. C语言要求的局部变量声明必须在所有的可执行语句之前，而C++没有这个限制

引入第一个概念

一.缺省参数（调用约定 _cdecl）

概念：缺省参数是声明或定义函数时为函数的参数指定一个默认的值，在调用函数时，如果没有指定实参则采用该默认值，否则使用指定的实参

全缺省参数：参数列表全都赋予了默认值

半缺省参数：参数列表部分赋予了默认值

    a）带缺省值的参数必须放在参数列表的最右面

    b）缺省参数不能同时在函数定义和声明时同时出现，只能出现一次，最好是声明

    c）缺省值必须是常量或者全局变量

    d）C语言中不支持

#include <iostream>

using namespace std;

int ret = 10;

void test(int a=1 ,int b=ret,int c=3)

{

            std::cout << "a=" << a << std::endl;

            std::cout << "b=" << b << std::endl;

            cout << "c=" << c << endl;

}

int main()

{

            int a = 0;

    std::cout << "This is test" << std::endl;

            cout << "hello" << endl;

            test(0);

            test(5);

            system("pause");

}

 

二.函数重载（静态多态）

函数重载是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数类型，个数，顺序）必须不同，常用来处理功能类似但数据类型不同的问题

1)条件：在同一作用域中，函数名必须相同，形参列表必须不同

2）函数返回值不能作为重载条件的原因：调用不明确，不知道调哪一个

3）函数重载的底层实现原理：C++底层有重命名机制，会根据函数返回值和参数列表对函数进行重命名

4）C语言为什么不能实现重载：

编译器在编译.c文件时，只会给函数进行简单的重命名；具体的方法是给函数名之前加上”_”;所以加入两个函数名相同的函数在编译之后的函数名也照样相同；调用者会因为不知道到底调用那个而出错；

5）仅是否带缺省参数并不能构造重载，编译器仍不知道调用哪个，参数类型，顺序，个数还是相同的

6）extern “C”是C++调用C语言已经编译过的函数，那么它就会遵循C原因调用规则，在函数名前加_，加上extern C之后就是让C++编译器去找服从C语言格式的这个函数，并调用

我们在C++ 程序中调用被 C 编译器编译后的函数时，添加extern “C”

Extern “C” int Add （int left ，int right）

1

2

原因：

①C++语言支持函数重载。而C不支持函数重载。

②函数在C中和C++中编译过的函数名字是不一样的。加上extern”C”是说明C已经编译过的。

C++想要调用已经编译过的C函数，由于编译过的名字不同，是不能直接调用的，所以C++加extern“C”生命来解决这个问题。

例如：假设某个函数的原型为： void foo(int x, int y);该函数被C 编译器编译后在库中的名字为_foo， 而C++ 编译器则会产生像_foo_int_int 之类的名字，加上extren”C”后，就相当于告诉编译器，函数foo是个C编译后的函数，在库里应该找的是_foo,而不是_foo_int_int.

VS中在map中，Linux生成了符号表 

cpp文件在linux虚拟机里需要用g++编译。 

安装g++很简单。命令： yum install gcc gcc-c++ 

安装好了之后就可以了。运行程序之后，使用命令：objdump a.out -t > test.out 

-t是表示生成符号表，最后是将生成的符号表用重定向符号放在test.out文件。打开test.out文件，就会发现，整形数相加的函数Add(int a,int b)生成的符号表中，Add函数名被记录为_Z3Addiii,其中。_Z表示符号表名称开始, 3代表函数名的字符个数，iii代表按顺序三个形参的类型； 

可以看出：同样的.cpp文件在window的vs2008编译器和linux的g++编译中，相同的函数名进过编译之后的重新命名不一样；

7）引用和同类型不带引用的实参不能构成重载

8）const和非const也能构成重载

void string1(char * buf)

{

            cout << buf << endl;

}

void string1(const char * buf)

{

            cout <<"const："<< buf << endl;

}

void constr(const char * buf)

{

            cout << buf << endl;

}

int main()

{

            char buf[12] = "1234";

            const char buf1[12] = "23456";

            string1(buf);

            string1(buf1);

            constr(buf);

            constr(buf1);

            system("pause");

}

结果：

 

三.引用

1.引用的由来

    C语言中函数参数只能通过传值和传址来完成，传值会在函数调用过程中生成一份临时变量用形参代替，最终把实参的值传给新参，浪费空间，        优点：避免函数调用的副作用缺点：无法改变形参的值

    要改变形参的值，只能通过指针传递，指针的使用比较复杂，所以C++中出现了引用

2、引用的概念

    引用不是定义一个新的变量，而是给已经存在的变量取一个别名，编译器不会为引用变量开辟新的空间，它和它所引用的变量共用同一块内存空间    使用：类型& 引用变量别名=引用实体

3.引用特性：

    a）引用在定义时必须初始化

    b）一个变量可以有多个引用

    c）一旦引用了某个实体，便再也不能更改

int a = 2;

int b = 3;

int& ra = a;

int * const pa = &a;   引用更像pa这样的指针，pa与a关联，并一直效忠于a

*pa = 10;

    d）引用的变量和初始化的类型必须相同

    e）不能为常量创建别名

            const int a = 10;

            const int& b = a;

            cout << b << endl;（可行，引用的时候没有const不可行）

            const int& d=5；常量具有常性，只有常引用可以引用常量

    double d1=1.1；

    int& dd1=d1；（不可行，double赋值给int要生成一个临时变量，也就是说dd1引用的是这个带有常属性的临时变量，所以不能赋值）

    const int& d2=d1；（可行，只读，只能缩小不能放大，原来是可读可写）

            double a = 1.1;

            const int& ra = a;

            cout << ra << endl; //1

4.C++中不能引用一个数组，但是可以建立数组的引用，就是给数组起别名

引用数组（不可行）

int &b[2] = { 0, 1 };

存放数组是需要空间的，但是系统并不为引用分配空间，所以不能引用数组

c++中，引用可以说只是某个变量的别名，所谓别名，是和指针类型区分开的，指针类型可以指向某个变量，而且指针类型本身也是一个变量，而引用本身实际上不是一个变量。更本质来说，可以理解为引用没有自身的地址，不占用内存空间，因此，声明引用数组没有办法分配内存空间，因为根本就没有空间可以分配给引用，所以不能声明和定义引用数组。

以下程序是数组的引用（可行）

int a[4] = { 0, 1, 2, 3 };

int(&ra)[4] = a;

cout << ra[2] << endl;

引用不能作为数组中的元素

    int a = 10;

    int& b = a;

    a = 30;

    int c[3] = { 0, 1, b };

    cout << c[2] << endl; //30

    cout << b << endl; //30

 

5.使用场景

    a）作为函数参数

交换两个数的值，就不用再传地址了，使用起来方便了

void  Swap(int& a, int& b)

{

            int tmp = a;

            a = b;

            b = tmp;

}   Swap(a, b);

    b）作为函数返回值

        注意不能引用栈上的变量

    汇编中的lea 是取地址-->取了寄存器的地址  原理：指针取地址

int& Fun(int a, int b)

{

            int c = a + b;

            return c;

}

int main()

{

            int & ret = Fun(2, 3);   

            cout << ret << endl;

            cout << ret << endl;

            cout << ret << endl;

   栈上的变量c被销毁，再次取值就取不到了

    1.不要返回一个临时变量的引用

    2.如果返回对象出了当前函数的作用域依然存在，最好引用返回，这样更高效

6.引用和指针的区别和练习（面试考点）

    a）相同点：底层的实现方式相同，都是按照指针实现的（反汇编的执行是一样的）

    

int a=10；

int& ra=a;

int *pa=&a;

 

    b）不同点

        1）表示方法不同，一个*，一个&

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

        3)一旦一个引用被初始化指向一个对象，就不能再更改，而指针可以在任何时候进行更改

        4）没有NULL引用，但有NULL指针

        5）在sizeof中含义不同，引用结果为所引用变量的大小，指针始终是地址*空间所占字节数 （指针大小就是地址所占字节数，32位机器上4个                字节，64位机器上占8个字节）（Win32 Linux-->x64 4字节）（x64 8个字节）（和程序有关系）

        6）引用自加改变变量的内容，指针自加改变了指针指向

        7）有多级指针，但是没有多级引用

        8）指针需要手动寻址，引用通过编译器寻址

        9）相对而言，引用比指针使用更安全（指针使用的时候要检查是否为NULL，解引用程序会崩）

此结构体大小也为36,

所以可得引用所占的空间和指针变量很类似。

总上所述可以得结论：引用的本质就是char *const p;引用在C++内部实现是用常指针实现的，所以引用所占的内存空间和指针大小相同，引用会让人误认为说变量的别名，没有自己的储存空间，这是C++为了实用性做出的细节隐蔽

7.几种传递效率的比较

    传引用>传址>传值

        传址要拷贝一份地址，传值要进行值拷贝，需要重新开辟一份相同的空间

 

四.命名空间（namespace）

一种新的作用域

1.使用命名空间的目的

    在C++中，变量函数类是大量存在的，这些变量，函数类和名称将都存在于全局命名空间中，会导致很多冲突，使用命名空间的目的是对标识符的名字进行本地化，以避免命名冲突和名字污染

namespace N1

{

            int a = 10;

            void print()

            {

                        cout << "namespace N1" << endl;

            }

};

using N1::a; //相当于把a声明成全局变量

using namespace N1;  //把N1中的成员方法都声明为全局de

int main()

{

            cout << a << endl;

            N1::print();

            system("pause");

}

不带命名空间名字的命名空间，它的成员和方法只在定义该命名空间的文件中可以访问，访问时不需要加命名空间的名称，对于其他文件该命名空间中的内容不可见

namespace

{

            int a = 10;

            void print()

            {

                        cout << "namespace N1" << endl;

            }

};

int main()

{

            cout << a << endl;

            print();

            system("pause");

}？？？

2.命名空间的作用

    一个命名空间就定义了一个新的作用域，命名空间中的所有内容局限于该命名空间中