C++语言（01）——C到C++的升级

2.3函数重载

本节只做简单介绍后续章节会再重点介绍

2.3.1、重载规则

A、函数名相同。
B、参数个数不同，参数的类型不同，参数顺序不同，均可构成重载。
C、返回值类型不同则不可以构成重载。

2.3.2、函数重载的匹配规则

A、严格匹配，找到则调用。
B、通过隐式转换寻求一个匹配，找到则调用。
C++允许int到long和double的隐式类型转换，因此遇到这种情型，则会引起二义性，解决方法是在调用时强转类型。

#include 
#include 
/*
int func(int x)
{
    return x;
}
*/
double func(int x)  //编译报错，前两个函数有歧义，可见返回值函数的返回值不能做为函数重载的依据
{                   //重载的条件：函数名相同，参数的（大小、类型、个数）至少有一个不同
    return x;
}

int func(int a, int b)
{
    return a + b;
}

int func(const char* s)
{
    return strlen(s);
}

int main(int argc, char *argv[])
{
    printf("%d\n", func(3));
    printf("%d\n", func(4, 5));
    printf("%d\n", func("D.T.Software"));

    return 0;
}

2.3.3、函数重载的底层实现

C++利用 name mangling(倾轧)技术，来改名函数名，区分参数不同的同名函数。
实现原理：用 vci f l d表示void char int float long double及其引用。
void func(char a); // func_c(char a)
void func(char a, int b, double c);//func_cid(char a, int b, double c);
name mangling发生在两个阶段，.cpp编译阶段，和.h的声明阶段。只有两个阶段同时进行，才能匹配调用。
C++完全兼容C语言，因此必须完全兼容C的类库。由于.c文件的类库文件中函数名并没有发生name manling行为，而在包含.c文件所对应的.h文件时，.h 文件要发生name manling行为，因而会在编译链接时候发生错误。
C++为了避免上述错误的发生，重载了关键字extern。只需要要避免name manling的函数前，加extern "C"如有多个，则extern "C"{}。
C语言标准库中实际上对C++语言程序引用时做了特殊处理，在C++语言编译器编译时使用extern "C"将C语言的标准库函数排除了命名倾轧。

#ifdef __cplusplus
extern “C”{
#endif
标准库函数
#ifdef __cplusplus
}
#endif

2.4操作符重载：

操作符的重载以函数的方式进行，本质是用特殊形式的函数扩展操作符的功能
操作符的重载不能改变操作符的原生语义

#include 

class Complex 
{
    int a;
    int b;
public:
    Complex(int a = 0, int b = 0)
    {
        this->a = a;
        this->b = b;
    }

    int getA()
    {
        return a;
    }

    int getB()
    {
        return b;
    }

    friend Complex Add(const Complex& p1, const Complex& p2);
};

Complex Add(const Complex& p1, const Complex& p2)

{
    Complex ret;

    ret.a = p1.a + p2.a;
    ret.b = p1.b + p2.b;

    return ret;
}

int main()
{

    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = Add(c1, c2); // c1 + c2

    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());

    return 0;
}

注意：逻辑运算符和逗号表达式重载后不能保持原生语义，原因在于函数参数计算时顺序是不确定的。

#include 
#include 

/**
实际工程中避免重载逻辑操作符，通过重载比较操作符代替逻辑操作符重载或使用成员函数代替逻辑操作符重载
    如果非要重载，使用全局函数进行
**/

using namespace std;

class Test
{
    int mValue;
public:
    Test(int v)
    {
        mValue = v;
    }
    int value() const
    {
        return mValue;
    }
};
//如果非要重载，使用全局函数进行
bool operator && (const Test& l, const Test& r)     //const对象只能调用const成员函数
{
    return l.value() && r.value();
}

bool operator || (const Test& l, const Test& r)
{
    return l.value() || r.value();
}

Test func(Test i)
{
    cout << "Test func(Test i) : i.value() = " << i.value() << endl;

    return i;
}

int main()
{
    Test t0(0);
    Test t1(1);

    //C++通过函数调用扩展操作符的功能，进入函数体前必须完成所有参数的计算，但参数的计算次序是不定的(短路法则失效)
    if( func(t0) && func(t1) )  // operator &&(func(0), func(1))
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }

    cout << endl;

    if( func(1) || func(0) )
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }

    return 0;
}

2.5默认参数&占位参数：

C++中引入了默认参数的概念，可以从左向右依次提供默认参数

#include 

int add(int x, int y = 0, int z = 0);   //设计函数时，参数的默认值必须从右向左提供

int main(int argc, char *argv[])
{
    printf("%d\n", add(1));
    printf("%d\n", add(1, 2));
    printf("%d\n", add(1, 2, 3));

    return 0;
}

int add(int x, int y, int z)
{
    return x + y + z;
}

一个函数，不能既作重载，又作默认参数的函数。当你少写一个参数时，系统无法确认是重载还是默认参数。
占位参数只有函数的参数类型声明，而没有参数名声明，为了兼容C语言的不规范写法

#include 

int func(int x, int);
// int func(int x, int = 0);    //解决方法是结合默认参数和占位参数

int main(int argc, char *argv[])
{
    printf("%d\n", func(1));    //这样可以使用不同的方法调用
    printf("%d\n", func(2, 3));

    return 0;
}

int func(int x, int)
{
    return x;
}

2.6引用：

引用是一个变量的别名，本质是一个指针常量。

int a,b;
int &r = a;
int &r = b; //错误，不可更改原有的引用关系
r = b;//正确，赋值
float &rr = b; //错误，引用类型不匹配
cout<<&a<<&r<

//E、常引用
const对象的引用必须是const的，将普通引用绑定到const对象是不合法的。const引用可使用相关类型的对象(常量,非同类型的变量或表达式)初始化，是const引用与普通引用最大的区别。 const int &a=2;是合法的。 double x=3.14; constint &b=a;也是合法的。
非const引用只能绑定到与该引用同类型的对象。
总结：
A、引用没有定义，是一种关系型声明。声明它和原有某一变量(实体)的关系。故 而类型与原类型保持一致，且不分配内存。与被引用的变量有相同的地址。
B、声明的时候必须初始化，一经声明，不可变更。
C、可对引用再次引用。多次引用的结果，是某一变量具有多个别名。
D、&符号前有数据类型时，是引用。其它皆为取地址。
E、不可定义引用的指针，不可定义引用数组（数组内部数据元素类型必须相同）

2.7new/delete：

C++中引入了新的内存分配机制
(1)C语言中通过malloc和free来申请和释放内存空间
(2)C++中使用new和delete来来申请和释放内存空间
(3)new和malloc的区别
1、new是C++中的关键字而malloc是C语言中的一个库函数
2、new以具体的类型为单位进行内存的分配，而malloc是以字节为单位进行内存分配
3、new在申请单个类型变量时可以进行初始化，而malloc不具有初始化的特新
(4)new的使用

//1、//申请type类型的空间
type *pointer = new type    
delete pointer
//2、//为type类型的数组申请空间，数组中有N个元素
type *pointer = new type[N] 
delete[] pointer    //此处的[]不能丢
//3、//申请type类型的空间,并赋值为1
type *pointer = new type(1) 
delete pointer

使用实例：

#include 

int main()
{
    int* p = new int;   //从字面来理解，为新类型int分配空间

    *p = 5;
    *p = *p + 10;

    printf("p = %p\n", p);
    printf("*p = %d\n", *p);

    delete p;

    p = new int[10];        //堆内存申明是一般所给的内存会比实际申请的要多一些
                            //所依此处至少分配了40字节的空间

    for(int i=0; i<10; i++)
    {
        p[i] = i + 1;

        printf("p[%d] = %d\n", i, p[i]);
    }

    delete[] p;         //此处的[]不可以丢

    return 0;
}

#include 

void static_cast_demo()
{
    int i = 0x12345;
    char c = 'c';
    int* pi = &i;
    char* pc = &c;

    c = static_cast(i);
    //pc = static_cast(pi);      //error
}

void const_cast_demo()
{
    const int& j = 1;       //定义了一个只读变量j
    int& k = const_cast(j);

    const int x = 2;        ////定义了一个常量x
    int& y = const_cast(x);   //当&/extern作用于一个常量时，c++也会像C语言中一样为其分配内存空间

    //int z = const_cast(x);       //error

    k = 5;

    printf("k = %d\n", k);      // 5
    printf("j = %d\n", j);      // 5

    y = 8;

    printf("x = %d\n", x);      // 2， x是常量，使用时从字符表取出
    printf("y = %d\n", y);      // 8
    printf("&x = %p\n", &x);    //y是x的引用（别名），共用同一内存空间
    printf("&y = %p\n", &y);
                                //&x = 0xbf8872dc
                                //&y = 0xbf8872dc
}

void reinterpret_cast_demo()
{
    int i = 0;
    char c = 'c';
    int* pi = &i;
    char* pc = &c;

    pc = reinterpret_cast(pi);
    pi = reinterpret_cast(pc);
    pi = reinterpret_cast(i);
    //c = reinterpret_cast(i);        // error
}

void dynamic_cast_demo()
{
    int i = 0;
    int* pi = &i;
    //char* pc = dynamic_cast(pi);   //error  
}

int main()
{
    static_cast_demo();
    const_cast_demo();
    reinterpret_cast_demo();
    dynamic_cast_demo();

    return 0;
}

try{
    int *p = new int[10];
}
catch(const std::bad_alloc e)
{
    return -1;
}
//C++ 内存申请失败不抛出异常版本
int *q = new (std::nothrow)int[10];
if(q == NULL)
    return -1;

#include 
namespace First     //从全局空间中划分出一块命名为First，类似于划分地域
{
    int i = 0;
}
namespace Second
{
    int i = 1;

    namespace Internal
    {
        struct P    //c++中此处的P即就是一个结构体类型，等价于C语言中的struct P
        {
            int x;
            int y;
        };
    }
}
int main()
{
    using namespace First;          //我们要在main函数中使用First命名空间中的一切
    using Second::Internal::P;      //我们要在main函数中使用Second命名空间中的Internal空间中的P这个结构体

    printf("First::i = %d\n", i);
    printf("Second::i = %d\n", Second::i);

    P p = {2, 3};       //C++ 里对struct关键字进行加强，可以直接定义结构体 

    printf("p.x = %d\n", p.x);
    printf("p.y = %d\n", p.y);

    return 0;
}

string str;
str = "china";
string str2 = " is great ";
string str3 = str2;

//A、赋值
string str3 = str2;
//B、加法
string combine = str + str2;
//C、关系
string s1 = "abcdeg";
string s2 = "12345";
if(s1>s2)
cout<<"s1>s2"<

string sArray[10] = {
"0",
"1",
"22",
"333",
"4444",
"55555",
"666666",
"7777777",
"88888888",
"999999999",
};
for(int i=0; i<10; i++)
{
cout<

int capacity()const;  //返回当前容量（即string中不必增加内存即可存放的元素个数）
int max_size()const;    //返回string对象中可存放的最大字符串的长度
int size()const;        //返回当前字符串的大小
int length()const;       //返回当前字符串的长度
bool empty()const;        //当前字符串是否为空
void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分