C++/C对比，C++关键字，const，引用，基本数据类型

C++98/03关键字
asm do if return typedef auto double inline short typeid bool dynamic_cast int signed typename break else long sizeof union case enum mutable static unsigned catch explicit namespace static_cast using char export new struct virtual class extem operator switch void const false private template volatile const_cast float protected this wchar_t continue for public throw while default friend register true delete gouto reinterpret_cast try

C++数据类型
基本数据类型（内置类型）：字符型char、整型int、浮
点型float/double、逻辑型bool、无类型void
非基本数据类型（自定义类型）：数组type[]、指针type*、结构体struct、联合体union、枚举enum、类class。

名字空间
名字空间域是随标准C++而引入的，它相当于一个更加灵活的文件域（全局域），可以用花括号把文件的一部分括起来，并以关键字namespace开头给它起一个名字

#include<iostream>
using namespace std;//C++库

//名字空间域
namespace name1
{
    int a = 0;
}
namespace name2
{
    int a = 1;
}

int main()
{
    cout << name2::a << endl;//：：是作用域解析符
    system("pause");
    return 0;
}
//名字空间域解决全局命名冲突的问题。

C&C++输入输出对比
cout是标准输出流对象，<<是输出操作符；
cin是标准输入流对象，>>是输入操作符；
endl是换行操作符；
他们都属于C++标准库，所以都在std的名字空间里面

//C语言
#include<stdio.h>
#include<stdlib.h>
int main()
{
    int i2 = 1;
    double d2 = 2.22;
    printf("C type: int->%d,double->%f\n", i2, d2);
    scanf("%d,%f", &i2, &d2);
    printf("C type: int->%d,double->%f\n", i2, d2);
    system("pause");
    return 0;
}

//C++
#include<iostream>
using namespace std;
int main()
{
    int i1 = 1;
    double d1 = 2.22;
    cout << "C++type:" << "int->" << i1 << " double->" << d1 << endl;
    cout << "please input and double:";
    cin >> i1 >> d1;//这里可以对i1和d1键盘输入值；
    cout << "C++type:" << "int->" << i1 << " double->" << d1 << endl;
    system("pause");
    return 0;
}

函数重载
在同一作用域类，一组函数的函数名相同，参数列表不同（个数不同/类型不同），返回值可同可不同。

缺省参数
//全缺省参数：传参时可以全部都不传；也可以只传第一个参数；也可以所有参数都传；切记不能只传后面的而不传第一个，例Add1( ,1);
//半缺省参数：在省略参数时不能缺省右边的参数；传参时可以只传缺省的左边的参数；也可以两个参数都传；但不能只传后面的而不传第一个

#include<iostream>
using namespace std;

//全缺省参数
int Add1(int a = 0, int b = 0)
{
    return a + b;
}
//半缺省参数（只能缺省左边的，不能缺省右边的）
int Add2(int a, int b = 0)
{
    return a + b;
}

void Test()
{
    Add1();//两个参数都省略
    Add1(1, 1);//两个参数都传值
    Add1(1);//值传第一个参数

    Add2(2);//只传缺省的左边的参数
    Add2(2, 2);//两个参数都传

    cout << Add1() << endl;
    cout << Add1(1, 1) << endl;
    cout << Add1(1) << endl;
    cout << Add2(2) << endl;
    cout << Add2(2, 2) << endl;
}
int main()
{
    Test();
    system("pause");
    return 0;
}

引用
引用不是定义一个新的变量，而是给一个已经定义的变量重新起一个别名。
定义的格式为：
类型&引用变量名 = 已定义过的变量名
引用的特点：
一个变量可以取多个别名；
引用必须初始化；
引用只能在初始化的时候引用一次，不能改变为再引用其他的变量。

在这里举一个简单的例子：
#include<iostream>
using namespace std;

void TestReference1()
{
    int a = 1;
    int& b = a;
    //验证b是a的别名，它们指向同一块儿地址
    cout << "a:address->" << &a << endl;//008FF858
    cout << "b:address->" << &b << endl;//008FF858

    a = 2;
    //改变a的值，b的值也跟着改变
    cout << "a: " << a << endl;//2
    cout << "b: " << b << endl;//2
    b = 3;
    //改变b的值，a的值也得到了改变
    cout << "a: " << a << endl;//3
    cout << "b: " << b << endl;//3
    int& c = b;//再取一个变量c为b的别名，此时b,c都为a的别名
    c = 4;
    //改变c的值，则a, b的值都跟着改变
    cout << "a: " << a << endl;//4
    cout << "b: " << b << endl;//4
    cout << "c: " << c << endl;//4
}

int main()
{
    TestReference1();
    system("pause");
    return 0;
}

const引用

#include<iostream>
using namespace std;

void TestReference2()
{
    int d1 = 4;
    const int & d2 = d1;
    d1 = 5; // d1改变 d2的值也会改变。
    //d2 = 6; // 不能给常量（不能被修改的量）赋值
    const int d3 = 1;//d3有const修饰时，它的别名也必须要有const修饰
    const int & d4 = d3;
    //int&d5 = d3;
    const int & d6 = 5; // 常量具有常性，只有常引用可以引用常量
    double d7 = 1.1;
    //int& d8 = d7; //d7是double类型，d8是int，d7赋值给 d8时要生成一个临时变量
    // 也就是说d8引用的是这个带有常性的临时变量，所以不能赋值。
    const int& d9 = d7;
}

int main()
{
    TestReference2();
    system("pause");
    return 0;
}

引用作为参数
【值传递】如果形参为非引用的传值方式，则生成局部零时变量接收实参的值

void Swap (int left, int right) // 函数里得到交换，而实参并没有交换
{
int temp = left;
left = right ;
right = temp ;
}

【引用传递】如果形参为引用类型，则形参是实参的别名

void Swap (int& left, int& right)//这里就可以将实参的值进行交换，与传指针很相似
{
int temp = left;
right = left ;
left = temp ;
}

【指针传递】

void Swap (int* pLeft, int* pRight)
{
int temp = *pLeft;
*pLeft = *pRight;
*pRight = temp;
}
void TestReference2 ()
{
int a = 1;
int b = 2;
cout<<"a:" <<a<< endl;
cout<<"b:" <<b<< endl;
Swap (a , b);
cout<<"a:" <<a<< endl;
cout<<"b:" <<b<< endl;
}

总结：引用传递的效率与指针传递的效率差不多，高于值传递的效率。
当不希望函数内改变参数x的值时，尽量使用常引用传参
例：
void ReadBigData (const bigData& x)
{
int a = x. array[100];
}
传值做返回值&传引用做返回值
传值返回时，是将ret的值放到eax寄存器中；
传引用返回时，是取ret的地址到eax寄存器中。
结论：若要返回的是一个临时变量的值时，就不用引用；
如果返回对象出了当前的作用域依旧存在，最好使用引用返回，因为这样更高效。
引用和指针的区别和联系
引用必须在定义时就初始化，切之后不能再改变指向其他变量；指针变量的值可以改变。
引用必须指向有效变量；指针可以为空指针。
sizeof指针对象和引用对象不一样，sizeof引用得到的是所指向的变量的大小，而sizeof指针是对象地址的大小。
指针和引用自增（++）自减（–）的意义不一样。
相对而言，引用比指针更安全。
【所以在使用指针的时候一定要检查指针是否为空，指针所指的地址释放以后最好置0】