C++与C的区别一

1. C++风格数组初始化：

#include <iostream>
#include <array>

using namespace std;

void main()
{
    //CPP一维数组初始化
    array<int, >MyInt{ ,,,,,,,,, };
    for (auto i : MyInt)
    {
        cout << i << " " << (void *)&i << endl;
    }

    //CPP二维数组初始化
    array<int, >MyInt1{ ,,,,,,,,, };
    array<int, >MyInt2{ ,,,,,,,,, };
    array<int, >MyInt3{ ,,,,,,,,, };

    array<array<int, >, >myInt{ MyInt1,MyInt2,MyInt3 };

    for (auto j : myInt)
    {
        for (auto i : j)
        {
            cout << i << " ";
        }
        cout << endl;
    }

    cin.get();
}

 2. CPP别名：

#include <iostream>

using namespace std;

//一般情况，原则上都用using取代typedef
//typedef处理不了模板，处理不了命名空间，统一用using
typedef double DB;        //C风格
using DBCPP = double;    //CPP风格别名

//数组别名
typedef int a[];
using IntArray = int[];

//函数指针
typedef int(*p)(int a, int b);        //函数指针类型，p
using pFun = int(*)(int a, int b);    //CPP函数指针别名

//函数指针数组
typedef int(*pa[])(int a, int b);
using ppFun = int(*[])(int a, int b);

void main()
{
    cout << sizeof(DB) << endl;       //
    cout << sizeof(DBCPP) << endl;    //

    IntArray int1;
    cout << sizeof(int1) << endl;     //

    cin.get();
}

3. auto 使用：

#include <iostream>

using namespace std;

//C++14自动推理返回值类型
//C++11需要指定返回值类型
auto add(int a, int b)->int        //此处int可换为decltype(a+b)
{
    return a + b;
}

//数控科技面试题：请问f是什么？
auto (*f)()->int(*)();
//int(*      (*fx)()       )()    //返回值是函数指针

//请推理下面pf是什么类型?
auto pf1()->auto(*)()->int(*)()
{
    return nullptr;    //返回空指针
}

auto pf2(void)->auto(*)(int x)->int(*)(int a,int b)
{
    return nullptr;    //返回空指针
}
//int(*       (*)(int x)       )(int a,int b)
//int(*       (*   pf2(void)        )(int x)       )(int a,int b)
//int(*(*   (void) )(int))(int,int)

auto go(int a, int b)->auto(*)()->int (*)(int, int(*)(int, int));
//int (*     (*)()      )(int, int(*)(int, int))
//int (*     (*   go(int a, int b)           )()      )(int, int(*)(int, int))
//int (* (* (int, int))(void))(int, int (*)(int,int))

void main()
{
    cout << typeid(f).name() << endl;
    cout << typeid(pf1).name() << endl;
    cout << typeid(pf2).name() << endl;
    cout << typeid(go).name() << endl;

    cin.get();
}

4. 函数模板的别名：

#include <iostream>
#include <array>

using namespace std;

//C++14自动推理返回值类型
//C++11需要指定返回值类型
template<class T1,class T2>
auto add(T1 t1, T2 t2)->decltype(t1 + t2)        //此处int可换为decltype(a+b)
{
    return t1 + t2;
}

//函数模板的别名
template<class T> using t = T;
template<class T> using tp = T*;
template<class T>
void show(T tx)
{
    t<int> t1(tx);        //一旦使用别名必须指定类型 <int>
    tp<int> tp1(&tx);    //初始化指针
    cout << t1 << " " << tp1 << endl;
}

template<class T> using ten = array<T, >;

void main()
{
    cout << add(, ) << endl;            //
    cout << add(1.1, 2.2) << endl;        //3.3

    int a = ;
    show(a);    

    using IntArray = array<int, >;    //相当于为模板起了别名，明确地指明了类型为array<int, 10>
    array<int, > MyInt;                //此时array<int, 10>代表一个类型
    IntArray MyInt2;

    //template<class T> using t = array<T, 10>;    //error C2951: 模板 声明只能在全局、命名空间或类范围内使用
    ten<int> t1{ ,,,,,,,,, };//模板别名不明确类型
    for (auto i : t1)
    {
        cout << i << " ";
    }

    cin.get();
}

5. 收缩转换：

#include <iostream>

using namespace std;

void main()
{
    char ch1();
    char ch2{  };    //赋初始值最好用大括号,保证数据类型安全转换

    cout << (int)ch1 << endl;    //-90    编译通过，产生溢出
    cout << (int)ch2 << endl;    //编译不通过，error C2397: 从“int”转换到“char”需要收缩转换

    cin.get();
}

6. 二进制：

#include <iostream>

using namespace std;

void main()
{
    int a = 0b1001;
    int b = 0B1101;

    cout << a << endl;    //
    cout << b << endl;    //

    cin.get();
}

7. 常量表达式constexpr ：

#include <iostream>

using namespace std;

int get1()
{
    return ;
}

constexpr int get2()    //constexpr返回值或其他表达式为常量
{
    return ;
}

void main()
{
    //int a[5+get1()];    //error C2131: 表达式的计算结果不是常数
    int a[ + get2()];    //编译成功

    cin.get();
}

8. lambda 表达式：

#include <iostream>
using namespace std;

void main()
{
    [] {cout << "hello world!" << endl; }();        //解决函数怀孕现象

    auto fun = [] {cout << "hello" << endl; };        //函数指针
    fun();//调用

    [] {cout << "hello C" << endl; }();                //匿名lambda表达式

    [](char *str) {cout << str << endl; }("你好！");//带参数(匿名)

    auto fun1 = [](double a, double b) {return a + b; };
    cout << fun1(, 20.1) << endl;        //30.1

    auto fun2 = [](double a, double b)->int {return a + b; };    //指定返回值类型,->在()与{}之间
    cout << fun2(, 20.1) << endl;        //

    int num = ;
    auto func = [](int num) {num = , cout << num << endl; };//遵循副本机制
    func(num);                        //
    cout << "main=" << num << endl;    //main=100

    cin.get();
}

#include <iostream>
#include <array>
#include <algorithm>
using namespace std;

void main()
{
    int num1 = ;
    int num2 = ;
    //[]() {cout << num1 << " " << num2 << endl; }();//error C3493: 无法隐式捕获“num1”，因为尚未指定默认捕获模式
    [=]() {cout << num1 << " " << num2 << endl; }();    //100 99

    //[=]() {num1=10,num2=20,cout << num1 << " " << num2 << endl; }();//error C3491: “num1”: 无法在非可变 lambda 中修改通过复制捕获
    [&]() {num1 = , num2 = , cout << num1 << " " << num2 << endl; }();//=只能读不可写；&读写外部变量
    cout << "main=" << num1 << " " << num2 << endl;        //main=10 20

    int num3 = ;
    int num4 = ;
    [=]()mutable {num3 = , num4 = , cout << num3 << " " << num4 << endl; }();    //10 20   mutable起到副本作用
    cout << "main=" << num3 << " " << num4 << endl;                                    //100 99

    int a = , b = , c = ;
    //a可读可写，bc只可读
    [&a, b, c]() {a = , cout << a << " " << b << " " << c << endl; }();    //20 9 8

    //mutable副本，能读能写,读的原本，写的副本
    [a, b, c]()mutable {a = , b = , c = , cout << a << " " << b << " " << c << endl; }();    //1 2 3 

    array<int, >MyInt{ ,,,,,,,,, };
    //lambda表达式嵌入使用
    for_each(MyInt.begin(), MyInt.end(), [](int num) {cout << num << " "; });                //显示
    cout << endl;
    for_each(MyInt.begin(), MyInt.end(), [](int &num) {num += , cout << num << " "; });    //修改
    cout << endl;
    for_each(MyInt.begin(), MyInt.end(), [](int num) {cout << num << " "; });                //显示

    cin.get();
}

9. 函数包装器：

#include <iostream>
#include <functional>    //函数包装器头文件

using namespace std;
using std::function;    //函数包装器

void go()
{
    cout << "go" << endl;
}

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

void main()
{
    function<void(void)> fun1 = go;                                    //包装函数
    fun1();

    function<void(void)> fun2 = []() {cout << "go lambda" << endl; };//包装lambda表达式
    fun2();

    function<int(int, int)> fun3 = ADD;
    cout << fun3(, ) << endl;

    function<int(int, int)> fun4 = [](int a, int b)->int {return a + b; };
    cout << fun4(, ) << endl;

    cin.get();
}

10. 模板元

#include <iostream>
using namespace std;

int get50(int n)
{
    if (n == )
        return ;
    else if (n == )
        return ;
    else
        return get50(n - ) + get50(n - );
}

//递归调用：函数反复调用，等待返回，浪费时间较多
//模板元实现递归加速
//执行速度快，编译的时候慢，代码会增加
//把运行的时间节约在编译的时候
//常使用在递归加速，游戏优化，此处的模板元仅仅适用于C++11
template<int N>
struct data
{
    //递归表达式
    enum
    {
        res = data<N - >::res + data<N - >::res
    };
};

template<>
struct data<>
{
    enum
    {
        res =
    };
};

template<>
struct data<>
{
    enum
    {
        res =
    };
};

void main()
{
    cout << data<>::res << endl;    //模板元，代码加速(将运行时间放在编译中执行)
    cout << get50() << endl;

    cin.get();
}

11. C++中的const :

#include <iostream>
using namespace std;

void run1(const int *p);        //可改变地址，不可改内容
void run2(int const *p);        //
void run3(int * const p);        //不可改地址，可改内容
void run4(const int * const p);    //地址内容均不能改
void run5(int const * const p);    //

void main()
{
    //C语言中：
    //const int num = 10;
    //*(int *)(&num) = 4;
    //printf("%d\n", num);    //4

    //const int n = 10;
    //int a[n];                //C++编译器自动优化，将n直接替换为10

    //int a = 10;
    //const int n = a;        //此时C++编译器不敢乱优化，不敢把n直接替换为a
    //int data[n];            //error C2057: 应输入常量表达式

    //const int a = 10;
    //const int n = a;
    //int data[n];

    //const int num = 10;
    //*(int *)(&num) = 3;
    //cout << (void *)&num << endl;    //优化，强行替换为10，寄存器
    //cout << *(&num) << endl;    //10
    //cout << num << endl;        //10

    //int a = 10;
    //const int num = a;
    //*(int *)(&num) = 3;
    //cout << (void *)&num << endl;    //直接读内存，此时为变量，不敢优化
    //cout << *(&num) << endl;    //3
    //cout << num << endl;        //

    const int num[] = { ,,,, };
    const int *p = num;
    *(int *)p = ;        //const数组没有优化，可以间接改变
    for (auto i : num)
        cout << i << " ";    //100 2 3 4 5
    cout << endl;

    cin.get();
}

12. 智能指针：

#include <iostream>
#include <memory>
#include <Windows.h>
using namespace std;

void cmem()
{
    while ()
    {
        double *p = new double[ *  * ];
        Sleep();
        delete p;        //释放
        Sleep();
    }
}

void autoptr()
{
    while ()
    {
        double *p(new double[ *  * ]);
        auto_ptr<double>autop(p);    //创建智能指针，接管这片内存，会自动回收

        Sleep();
    }
}

void autoptrnew()
{
    while ()
    {
        Sleep();
        unique_ptr<double>p(new double[ *  * ]);
        Sleep();
    }
}

void main()
{
    //cmem();
    autoptr();
    autoptrnew();

    cin.get();
}

13. 多元数组 tuple ：

#include <iostream>
#include <tuple>
using namespace std;

//多元数组，存取不同的数据类型
void main()
{
    char ch = 'X';
    short sh = ;
    int num = ;
    double db = ;
    char *p = "calc";

    tuple<char, short, int, double, char *>MyTuple(ch, sh, num, db, p);

    auto autov1 = get<>(MyTuple);    //多元数组不能用for(auto i:MyTuple)的方式遍历
    cout << autov1 << endl;
    auto autov2 = get<>(MyTuple);
    cout << autov2 << endl;
    auto autov3 = get<>(MyTuple);
    cout << autov3 << endl;
    auto autov4 = get<>(MyTuple);
    cout << autov4 << endl;
    auto autov5 = get<>(MyTuple);
    cout << autov5 << endl;

    cin.get();
}

14. 左值引用与右值引用：

#include <iostream>
using namespace std;

//C++能用引用的情况，就别用指针
void change(int & rnum)
{
    rnum = ;
}

void main0501()
{
    //int num(10);        //num是左值，有内存实体，可以赋值    int num=10;
    //int & rnum(num);    //引用&就是变量的别名
    //
    //rnum = 1;            //rnum等价于num的别名
    //change(num);

    //cout << num << endl;    //111

    //int num = 1;
    //int data = 0;
    //cout << (void *)&data << endl;
    //data = num + 1;
    //data = num + 2;
    //data = num + 3;
    //cout << data << endl;

    //右值引用
    int num = ;
    int && rnum(num + );    //右值引用,快速备份寄存器的值。编译器会自动回收
    printf("%p\n", &rnum);

    //若是左值引用，需要两步：
    int data = num + ;
    int &rdata(data);

    int a[]{ ,,,, };
    int *p(a);
    cout << *p << endl;        //

    int * & rp(p);            //左值引用改变指针  & 放在类型与变量名之间
    rp += ;
    cout << *p << endl;        //

    int * && rrp(p + );    //右值引用改变指针 &&
    //int * && rrp(&a[1]);
    cout << *rrp << endl;    //

    cin.get();
}

void showit(int && rrnum)    //右值引用
{
    cout << rrnum << endl;
}

void main()
{
    int a[]{ ,,,, };

    showit(a[] + );

    //移动语义：将左值转化为右值(左值一定可以变为右值，右值不一定可变为左值)
    showit(move(a[]));

    cin.get();
}

15. 引用的本质：

#include <iostream>
using namespace std;

void main0601()
{
    int num = ;
    int data = ;
    int & rnum(num);    //引用一旦初始化，就不会再引用其他变量
    rnum = data;

    cout << num << endl;    //
    cout << data << endl;    //

    cin.get();
}

void main()
{
    double db;
    //double & rdb;                    //error C2530: “rdb”: 必须初始化引用
    double & rdb(db);
    cout << sizeof(rdb) << endl;        //

    struct MyStruct        //引用的本质是指针实现的，为了简化程序
    {
        double & rdb;
    };
    cout << sizeof(MyStruct) << endl;    //

    cin.get();
}

16. 引用指针以及作为函数参数和函数返回值：

#include <iostream>
using namespace std;

//改变指针，需要二级指针
//C++中可用引用
void main0701()
{
    int a();            //初始化为4
    int *p(new int());    //开辟int大小空间,值为5
    cout << a << endl;    //
    cout << *p << endl;    //5

    //int & ra(a);        //引用变量
    //int * & rp(p);    //引用指针
    //ra = 3;
    //*rp = 12;
    //cout << a << endl;    //3
    //cout << *p << endl;    //

    int && rra(move(a));    //右值引用，有内存实体就直接引用，没有内存实体则新开辟内存
    int * && rrp(move(p));
    rra = ;
    cout << rra << endl;
    cout << a << endl;

    //int        整数类型
    //int &        引用整数，本质是指针
    //int &&    引用整数，本质是指针，能处理左值（move）   和右值

    cin.get();
}

int num1 = ;
int num2 = ;

void change(int * &rp)    //C++中能用引用就别用指针
{
    rp = &num2;
}

void main0702()
{
    int *p = &num1;
    change(p);
    cout << *p << endl;    //

    cin.get();
}

void main0703()
{
    int *p(nullptr);

    int **pp(&p);
    int ** &rpp(pp);        //VS2015    C++14

    //int **pp(&p);
    //int(** (&rpp))(pp);    //VS2013    C++11

    cin.get();
}

void main0704()
{
    int ***ppp(nullptr);
    int *** & rppp(ppp);

    cin.get();
}

int data1 = ;
int data2 = ;
int *p = &data1;

void changeit(int ** &rpp)
{
    *rpp = &data2;
}

void main0705()
{
    int **pp = &p;    //二级指针
    cout << **pp << endl;    //
    changeit(pp);
    cout << **pp << endl;    //

    cin.get();
}

//返回一个引用a
int getdata()
{
    int num = ;
    return num;        //函数返回值有副本机制
}

void main0706()
{
    cout << getdata() << endl;    //

    cin.get();
}

//函数返回值有副本机制,返回变量
//栈区，自动回收、释放，返回为指针不能指向栈区，返回为引用不能应用栈区
int & getdata1()
{
    int num = ;
    return num;        //函数返回值有副本机制
}

void main0707()
{
    int & rnum = getdata1();    //此时引用的是原来的内存，调用后已经释放
    cout << "hello" << endl;
    cout << rnum << endl;        //此处结果并不是10

    int rnum2 = getdata1();        //拷贝到新的内存rnum2中
    cout << rnum2 << endl;        //

    cin.get();
}

int & getdata2()
{
    int *p(new int());    //堆区
    return *p;
}

void main0708()
{
    int & rnum = getdata2();    //此时引用的是堆区
    cout << "hello" << endl;
    cout << rnum << endl;        //

    cin.get();
}

char * & getcode()
{
    char *p = "hellohellohello";    //常量字符串-->代码区（与程序供存亡）
    return p;                        //p在栈上，但指向内容在代码区
}

void main()
{
    char * &rp = getcode();            //指针，引用p,但这个p在栈上，消亡了
    char * newp = rp;    //保存rp存储代码区地址
    cout << "hello china" << endl;
    cout << newp << endl;    //hellohellohello
    cout << rp << endl;        //乱码

    cin.get();
}

17. 引用数组：

#include <iostream>
using namespace std;

void main0801()
{
    int a[]{ ,,,, };                            //一维数组
    int *pa[]{ a,a + ,a + ,a + ,a +  };        //指针数组

    int b[][]{ ,,,,, };        //二维数组
    //二维数组，每一个元素是一个指针
    int *pb[][]{ &b[][],&b[][] + ,&b[][] + ,&b[][] + ,&b[][] + ,&b[][] +  };

    int *p1(new int[]{ ,,,, });                //堆上的一维数组
    int(*p2)[] = new int[][]{ {,,,},{,,,},{,,,} };    //堆上的二维数组

    cin.get();
}

void main0802()
{
    int a[]{ ,,,, };
    int(&ra)[](a);            //引用一维数组
    for (auto i : ra)
        cout << i << " ";
    cout << endl;

    int *pa[]{ a,a + ,a + ,a + ,a +  };
    int *(&rpa)[](pa);        //引用指针数组
    for (auto i : rpa)
        cout << *i << " ";
    cout << endl;

    cin.get();
}

void main0803()
{
    int *p1(new int[]{ ,,,, });
    int **pp(new int *[]{ p1,p1 + ,p1 + ,p1 + ,p1 +  });    //堆上指针数组
    int * &rp(p1);
    int ** &rpp(pp);

    cin.get();
}

void main0804()
{
    int b[][]{ ,,,,, };        //二维数组
    //二维数组，每一个元素是一个指针
    int *pb[][]{ &b[][],&b[][] + ,&b[][] + ,&b[][] + ,&b[][] + ,&b[][] +  };

    int(&rb)[][](b);        //引用二维数组
    int *(&rpb)[][](pb);    //引用二维指针数组

    cin.get();
}

void main()
{
    //int(*p2)[4] =  (new int[3][4]{ { 1,2,3,4 },{ 5,6,7,8 },{ 9,10,11,12 } });    //堆上的二维数组

    //指向数组的指针，用{}初始化
    int(*p2)[]{ new int[][]{ { ,,, },{ ,,, },{ ,,, } } };
    int(*&rp)[](p2);    //引用行指针
    for (int i = ; i < ; i++)
    {
        for (int j = ; j < ; j++)
            cout << rp[i][j]<<"   ";
        cout << endl;
    }

    int * (*pp)[]{ new int *[][] };    //堆上开辟二维指针数组
    int * (*&rpp)[](pp);                //引用二维指针数组

    cin.get();
}

18. const 与引用：

#include <iostream>
using namespace std;

void main0901()
{
    int num = ;
    int const & rnum(num);    //const限定引用权限,只能读不能写
    //const int & rnum(num);    //与上面一样
    //rnum=3;    //不能写
    cout << rnum << endl;

    cin.get();
}

//void main0902()
//{
//    int num = 100;
//    int & const rnum(num);    //const放在&右边没有影响
//    rnum=3;
//    cout << rnum << endl;
//
//    cin.get();
//}

void main0903()
{
    int a[]{ ,,,, };
    const int(&ra)[](a);    //只能读不能写
    for (auto i : ra)
        cout << i << " ";
    cout << endl;

    cin.get();
}

void main0904()
{
    //int *p(new int(5));    //堆上指针初始化
    //int *(&rp)(p);
    //*rp = 3;
    //cout << *p << endl;

    const int *p(new int());    //指针，指向常量
    const int (*(&rp))(p);        //引用一个指向常量的指针
    //*rp = 3;
    cout << *p << endl;

    cin.get();
}

void main0905()
{
    int * const p(new int());    //地址不能变，值可以变
    int * const (&rp)(p);        //引用一个常量指针
    *p = ;

    cin.get();
}

void main0906()
{
    const int * const p(new int());    //地址不能变，值也不能变
    const int * const (&rp)(p);            //引用一个指向常量的常量指针
    //*p = 1;

    cin.get();
}

void main()
{
    int *p(new int());
    //const int *(&rp)(p);    //error C2440: “初始化”: 无法从“int *”转换为“const int *&”
    const int *(&rp)((const int *&)p);    //强制转换

    cin.get();
}

19. 引用与函数指针：

#include <iostream>
#include <cstdlib>
using namespace std;

//函数指针引用作为参数，可以改变函数指针
//函数指针引用作为返回值，可以实现调用getitp(p)("hello world");
int gocmd(const char *cmd)
{
    system(cmd);
    return ;
}

int showcmd(const char *cmd)
{
    cout << cmd << endl;
    return ;
}

void change(int(* & p)(const char *cmd))    //函数指针的引用做参数
{
    p = showcmd;
}

//getp()返回一个函数指针
int(*    getp()    )(const char *cmd)
{
    int(*( p))(const char *cmd)(gocmd);
    return p;
}

//getitp()返回一个函数指针的引用，并且参数是一个函数指针的引用
int(* &   getitp(   int(*& p)(const char *cmd)    )     )(const char *cmd)
{
    p = showcmd;
    return p;
}

void main()
{
    int(*p)(const char *cmd)(gocmd);    //定义函数指针并初始化
    //p("calc");

    ////change(p);
    //p = getp();    //通过返回值来赋值

    //p("echo hello world");

    getitp(p)("hello world");    //首先getitp(p)返回一个函数指针的引用，然后继续执行后面语句

    cin.get();
}

20. 引用与指针的差别：

#include <iostream>
using namespace std;

struct MyStruct
{
    int *p1;        //
    int & p2;        //
    double & p3;    //
};        //引用本质就是指针

//int & getint1()
//{
//    int a = 5;
//    return a;    //返回局部变量或临时变量的地址
//}

int & getint2(int & rint)    //参数、返回都是地址,此时引用的是外部传入的参数
{
    rint = ;
    return rint;
}

void main()
{
    //cout << sizeof(MyStruct) << endl;

    int a = ;
    int *p(new int());

    //getint2(a);
    //getint2(*p);

    int & ra(a);    //引用，栈上,4个字节

    cin.get();
}