C语言过渡C++基础知识¶

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

//命名空间1
namespace test1
{
    //变量
    int i = 0;

    //类型
    struct Student
    {
        int age;
        char name[20];
    };

    //函数
    int add(int x, int y)
    {
        return x + y;
    }
}

namespace 命名空间名
{
    //变量/函数/类型
}//注意最后一行不需要分号，不同于结构体

//命名空间2
namespace test2
{
    int num = 0;
    //命名空间3
    namespace test3
    {
        int num = 0;
    }
}

//头文件NameSpace.h中的命名空间4
//将rand变量放入命名空间test4中
namespace test4
{
    int rand = 10;
}

//测试文件
//C++主函数
#include <iostream>
#include <stdlib.h>
#include "NameSpace.h"

int main()
{
    //调用命名空间4中的rand变量，而不是标准库中的rand()函数
    printf("%d\n", test4::rand);
    return 0;
}
输出结果：
10

空间 :: 变量/类型/对象名

//NameSpace.h文件中的命名空间2与嵌套的命名空间3
//命名空间2
namespace test2
{
    int num = 20;
    //命名空间3
    namespace test3
    {
        int num = 30;
    }
}

//C++主函数
#include <iostream>
#include <stdlib.h>
#include "NameSpace.h"

//全局变量
int num = 10;

int main()
{
    //作用域限定符
    //局部变量
    int num = 0;
    printf("%d\n", num);
    //全局变量
    printf("%d\n", ::num);
    //指定命名空间的变量
    printf("%d\n", test2::num);
    //嵌套的命名空间的变量
    printf("%d\n", test2::test3::num);
    return 0;
}
输出结果：
0
10
20
30

//NameSpace.h中的命名空间1
namespace test1
{
    //变量
    int i = 10;

    //类型
    struct Student
    {
        int age;
        char name[20];
    };

    //函数
    int add(int x, int y)
    {
        return x + y;
    }
}

//加命名空间名称及作用域限定符
#include <iostream>
#include "NameSpace.h"

int main()
{
    printf("%d", test1::i);

    return 0;
}
输出结果：
10

//部分展开
#include <iostream>
#include "NameSpace.h"
using test1::i;// 部分展开

int main()
{
    printf("%d", i);
    return 0;
}
输出结果：
10

//全局展开
#include <iostream>
#include "NameSpace.h"
using namespace test1;

int main()
{
    printf("%d\n", i);
    return 0;
}
输出结果：
10

//NameSpace.h中的两个重名的命名空间
//两个同名的命名空间
namespace test5
{
    int num1 = 10;
}

namespace test5
{
    int num2 = 20;
}

//测试文件
//同名命名空间合并
#include <iostream>
#include "NameSpace.h"
using namespace std;
using namespace test5;

int main()
{
    cout << test5::num1 << endl;
    cout << test5::num2 << endl;
    return 0;
}
输出结果：
10
20

//NameSpace.h头文件
namespace test5
{
    int num1 = 10;
}

//test.cpp中包含头文件
#include "NameSpace.h"

//test1.cpp中包含头文件
#include "NameSpace.h"

//此时会提示报错，因为test.cpp和test1.cpp两个文件中都出现了相同的命名空间中的变量，导致变量多次定义

//C++的输入和输出
#include <iostream>
using namespace std;

int main()
{
    int num = 0;
    cout << "请输入数值：";
    cin >> num;
    cout << num << endl;

    return 0;
}
输入：
10
输出结果：
请输入数值：10
10

#include <iostream>
using namespace std;

int main()
{
    int num = 0;
    double num1 = 0;
    char c = 0;
    cin >> num >> num1 >> c;//多组内容的输入，相当于scanf("%d%lf%c", &num, &num1, &c);
    cout << num << ' ' << num1 << ' ' << c;//多组内容输出，相当于printf("%d %f %c", num, num1, c);

    return 0;
}
输入：
1 2.5 c
输出结果：
1 2.5 c

//C++的输入和输出
#include <iostream>

int main()
{
    int num = 0;
    std::cin >> num;
    std::cout << num << std::endl;

    return 0;
}
输入：
10
输出：
10

istream& getline (istream& is, string& str);

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

#include <iostream>
using namespace std;

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

int main()
{
    //调用add函数不传参数
    cout << add() << endl;
    //调用add函数传一个参数，使用右侧第一个缺省值
    cout << add(1) << endl;
    //调用add函数传两个参数
    cout << add(1, 2) << endl;

    return 0;
}
输出结果：
0
1
3

//缺省参数
#include <iostream>
using namespace std;

int add1(int x = 0, int y = 0, int z = 0)
{
    return (x + y + z);
}

int main()
{
    //使用缺省参数时必须从右往左连续使用

    //正确使用方法
    add1(1, 2);//使用第三个缺省参数，使用右侧第一个缺省参数
    add1(1);//使用右侧第二个和第三个缺省参数
    add1();//使用全部缺省参数
    add1(1, 2, 3);//不使用缺省参数

    //错误使用方法
    add1(1, , 2);//不可以直接使用第二个缺省参数
    add1(, 1, 2);//不可以直接使用第一个缺省参数
    add1(, , 1);//不可以直接使用第一个和第二个缺省参数
    add1(, 1, );//不可以直接使用第一个和第三个缺省参数

    return 0;
}

int add1(int x = 0, int y = 0, int z = 0)
{
    return (x + y);
}

int add1(int x, int y = 0, int z = 0)//只有y和z是缺省变量
{
    return (x + y + z);
}

//半缺省参数
int add2(int x, int y = 0, int z = 0)
{
    return (x + y + z);
}

int add3(int x, int y, int z = 0)
{
    return (x + y + z);
}

//不可以跳跃式给缺省值
int add4(int x = 0, int y, int z)// 跳过右侧开始的第一个和第二个参数，给第三个参数x缺省值
{
    return (x + y + z);
}

int add5(int x, int y = 0, int z)// 跳过右侧开始的第一个参数给第二个参数y缺省值
{
    return (x + y + z);
}

int main()
{
    add2(1);//只有一个不是缺省参数时，必须为该形参传递实参
    add3(1, 2);//有两个不是缺省参数时，必须为两个形参传递实参

    add4(, 2, 3);//不可以使用，需要满足从右往左使用缺省参数的原则
    add5(1, , 3);//不可以使用，需要满足从右往左使用缺省参数的原则
    return 0;
}

//NameSpace.h中的函数声明
int add6(int a = 20);

//测试文件
//定义不给缺省值
int add6(int a)
{
    return a;
}

#include <iostream>
#include "NameSpace.h"
using namespace std;

int main()
{
    cout<<add6(2)<<' ';
    cout<<add6()<<'\n';// 使用声明中的缺省值
    return 0;
}
输出结果:
2 20

//参数类型不同的重载
//整型参数
int add(int a, int b)
{
    return a + b;
}
//浮点型参数
double add(double a, double b)
{
    return a + b;
}

//参数个数不同的重载
//两个参数
int add(int a, int b)
{
    return a + b;
}
//三个参数
int add(int a, int b, int c)
{
    return a + b + c;
}

//不同类型的但数量相同情况下的不同参数顺序的重载
//注意变量名不需要更改顺序
//int类型在前，char类型在后
int getcharacter(int a, char b)
{
    return b;
}
//char类型在前，int类型在后
int getcharacter(char a, int b)
{
    return a;
}

//函数重载
//针对整型的加法函数
int add(int a, int b)
{
    return a + b;
}

//针对浮点型的加法函数
double add(double a, double b)
{
    return a + b;
}

//整型加法
int add(int a, int b)
{
    return a + b;
}
//浮点型加法
double add(double a, double b)
{
    return a + b;
}
#include <iostream>
using namespace std;

int main()
{    
    //传哪种类型值就调用哪种类型的函数
    cout <<"整型加法：" << add(1, 2) << endl;
    cout <<"浮点型加法："<< add(1.1, 2.2) << endl;
    return 0;
}
输出结果：
整型加法：3
浮点型加法：3.3

//缺省参数与函数重载
int add(int a = 10, int b = 20)
{
    return a + b;
}

int add(int a, int b = 30)
{
    return a + b;
}
//将会报错为add函数重定义

//指针中的swap函数
void swap(int* num1, int* num2)
{
    int tmp = *num1;
    *num1 = *num2;
    *num2 = tmp;
}

//使用引用的函数
void swap(int& num1, int& num2)
{
    int tmp = num1;
    num1 = num2;
    num2 = tmp;
}

#include <iostream>
using namespace std;

int main()
{

    //C语言中的swap函数
    int a = 1;
    int b = 0;
    cout << "指针交换" << endl;
    cout << "交换前：" << endl;
    cout << a << " " << b << endl;
    swap(&a, &b);
    cout << "交换后：" << endl;
    cout << a << " " << b << endl;

    //C++中使用引用的swap函数
    a = 1;
    b = 0;
    cout << endl;
    cout << "引用交换" << endl;
    cout << "交换前：" << endl;
    cout << a << " " << b << endl;
    swap(a, b);
    cout << "交换后：" << endl;
    cout << a << " " << b << endl;

    return 0;
}
输出结果：
指针交换
交换前：
1 0
交换后：
0 1

引用交换
交换前：
1 0
交换后：
0 1

引用实体的类型 &引用变量名 = 引用实体;

//引用与指针
#include <iostream>
using namespace std;

int main()
{
    int a = 0;
    //指针类型
    int* p = &a;
    cout << "指针修改前：" << endl;
    cout << a << endl;
    *p = 1;
    cout << "修改后：" << endl;
    cout << a << endl;

    //引用类型
    a = 0;
    int& rp = a;
    cout << "引用修改前：" << endl;
    cout << a << endl;
    rp = 1;
    cout << "修改后：" << endl;
    cout << a << endl;

    //引用实体为指针类型
    a = 0;
    int*& rpp = p;
    cout << "引用类型为指针修改前：" << endl;
    cout << a << endl;
    *rpp = 1;
    cout << "修改后：" << endl;
    cout << a << endl;

    //引用变量作为引用实体
    a = 0;
    int& r = rp;
    cout << "引用类型为引用变量修改前：" << endl;
    cout << a << endl;
    r = 1;
    cout << "修改后：" << endl;
    cout << a << endl;
    return 0;
}
输出结果：
指针修改前：
0
修改后：
1
引用修改前：
0
修改后：
1
引用类型为指针修改前：
0
修改后：
1
引用类型为引用变量修改前：
0
修改后：
1

//指针可以更改指向，引用不可以
#include <iostream>
using namespace std;

int main()
{
    int a = 0;
    //变量a给引用变量b
    int& b = a;
    cout << "初始a中的值：" << a << endl;
    //通过引用b改变a的值
    b = 20;
    cout << "通过引用改变a中的值：" << a << endl;

    //改变引用a实体的引用变量b使其指向c
    cout << "初始a中的值：" << a << endl;
    int c = 10;
    cout << "初始c中的值" << c << endl;
    b = c;
    cout << "现在a中的值：" << a << endl;
    //通过引用b改变c的值
    b = 30;
    cout << "当前c中的值" << c << endl;
    cout << "当前a中的值：" << a << endl;

    return 0;
}
输出结果：
初始a中的值：0
通过引用改变a中的值：20
初始a中的值：20
初始c中的值10
现在a中的值：10
当前c中的值10
当前a中的值：30
//从上面的结果中可以看到，尽管b引用显式得改变了指向，使其指向c，但是实际上只是将c中的值给了b引用，而因为引用b的指向不可以改变，故依旧改变的是a中的值

//sizeof
#include <iostream>
using namespace std;

int main()
{
    //一个变量可以有多个引用和指针
    int a = 0;
    //引用指向变量a
    int& r = a;
    //创建指针和指针的引用
    int* p = &a;
    int*& r2 = p;

    cout << "计算引用变量大小：(引用int类型)" << sizeof(r) << endl;
    cout << "计算引用变量大小：(引用int*类型)" << sizeof(r2) << endl;
    cout << "计算引用指针大小：(64位机，指向int类型)" << sizeof(p) << endl;

    return 0;
}
输出结果：
计算引用变量大小：(引用int类型)4
计算引用变量大小：(引用int*类型)8
计算引用指针大小：(64位机，指向int类型)8

//引用变量和指针+1操作
#include <iostream>
using namespace std;

int main()
{
    int arr[4] = { 1,2,3,4 };
    int& a1= arr[0];
    int* a2 = &arr[0];
    //const int*& a4 = &arr[0];//无法初始化
    cout << "计算引用实体类型为int类型+1跳过的大小" << endl;
    cout << "开始位置：" << &arr[0] << " " << "对应数值：" << arr[0] << endl;
    cout << "结束位置对应数值：" << a1 + 1 << endl;
    cout << "计算指针+1跳过的大小" << endl;
    cout << "开始位置：" << &arr[0] << " " << "对应数值：" << arr[0] << endl;
    cout << "结束位置：" << a2 + 1 << endl;
    cout << "计算引用实体类型为int*类型+1跳过的大小" << endl;
    a2 = arr;
    int*& a3 = a2;
    // const int*& a4 = &arr[0];//注意不可以使用这种写法，因为当前编译器不知道到底右侧值是否可以修改
    cout << "开始位置：" << &arr[0] << " " << "对应数值：" << arr[0] << endl;
    cout << "结束位置：" << a3 + 1 << endl;

    return 0;
}
输出结果：
计算引用实体类型为int类型+1跳过的大小
开始位置：000000970C4FF7B8 对应数值：1
结束位置对应数值：2
计算指针+1跳过的大小
开始位置：000000970C4FF7B8 对应数值：1
结束位置：000000970C4FF7BC
计算引用实体类型为int*类型+1跳过的大小
开始位置：000000970C4FF7B8 对应数值：1
结束位置：000000970C4FF7BC

//引用本身的地址和指针本身的地址
#include <iostream>
using namespace std;

int main()
{
    //一个变量可以有多个引用和指针
    int a = 0;
    //两个引用指向同一个变量a
    int& r = a;
    //两个指针指向同一个变量a
    int* p = &a;
    int*& r2 = p;

    cout << "引用实体为int类型变量的地址：" << &r << endl;
    cout << "引用实体为int*类型变量的地址" << &r2 << endl;
    cout << "指针变量指向的int类型变量的地址" << p << endl;
    cout << "指针变量自身的地址" << &p << endl;
    return 0;
}
输出结果：
引用实体为int类型变量的地址：0000000C97EFF5A4
引用实体为int*类型变量的地址0000000C97EFF608
指针变量指向的int类型变量的地址0000000C97EFF5A4
指针变量自身的地址0000000C97EFF608

//常量引用
#include <iostream>
using namespace std;

int main()
{
    //对于常量来说，需要使用常量引用变量才能引用常量实体
    const int a = 0;
    const int& a1 = a;// a为const修饰的常量
    const int& a2 = 10;//10为常量值
    double d = 2.34;
    //int& a3 = d;//无法编译，但不是类型不同的原因，而是因为强制转换产生的临时变量具有常性
    const int& a3 = d;//可以编译
    //const int* p = d;//但是指针无法做到同样的实现，原因是类型不同
    return 0;
}

//返回值
int add(int a, int b)
{
    static int z = a + b;
    return z;
}

#include <iostream>
using namespace std;

int main()
{
    int ret = add(1, 2);
    cout << ret << endl;
    return 0;
}
输出结果：
3

//返回引用
int& add(int a, int b)
{
    static int z = a + b;
    return z;// 离开add作用域不会销毁，所以可以使用引用返回
}

#include <iostream>
using namespace std;

int main()
{
    int ret = add(1, 2);
    cout << ret << endl;
    return 0;
}
输出结果：
3

#include <iostream>
using namespace std;

int& add(int a, int b)
{
    int z = a + b;
    return z;// 局部变量在出了add函数会销毁
}

int main()
{
    int& ret = add(1, 2);
    //int ret = add(1, 2);//依旧会有问题
    cout << ret << endl;
    cout << "输出结果：" << ret << endl;
    return 0;
}
输出结果：
3
输出结果：-858993460
//编译器警告：返回局部变量或临时变量的地址: z

#include <iostream>
using namespace std;

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
    // 以值作为函数的返回值类型
    size_t begin1 = clock();
    for (size_t i = 0; i < 100000; ++i)
        TestFunc1();
    size_t end1 = clock();
    // 以引用作为函数的返回值类型
    size_t begin2 = clock();
    for (size_t i = 0; i < 100000; ++i)
        TestFunc2();
    size_t end2 = clock();
    // 计算两个函数运算完成之后的时间
    cout << "TestFunc1 time:" << end1 - begin1 << endl;
    cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main()
{
    TestReturnByRefOrValue();
    return 0;
}
输出结果：
TestFunc1 time:161
TestFunc2 time:1

#include <iostream>
using namespace std;

void swap(int& num1, int& num2)
{
    int tmp = num1;
    num1 = num2;
    num2 = tmp;
}

int main()
{
    int a = 1;
    int b = 0;
    cout << "交换前的a和b：" << "a = " << a << " " << "b = " << b << endl;
    swap(a, b);
    cout << "交换后的a和b：" << "a = " << a << " " << "b = " << b << endl;
    return 0;
}
输出结果：
交换前的a和b：a = 1 b = 0
交换后的a和b：a = 0 b = 1

#include <iostream>
using namespace std;
#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
    A a;
    // 以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc1(a);
    size_t end1 = clock();
    // 以引用作为函数参数
    size_t begin2 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc2(a);
    size_t end2 = clock();
    // 分别计算两个函数运行结束后的时间
    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

int main()
{
    TestRefAndValue();
    return 0;
}
输出结果：
TestFunc1(A)-time:15
TestFunc2(A&)-time:0