C++与C的区别二

1. new,delete的局部重载：

#include <iostream>
using namespace std;
 
int objs = ;
 
class myclass
{
public:
    myclass()
    {
        //objs++;
        cout << "create" << endl;
    }
    ~myclass()
    {
        //objs--;
        cout << "delete" << endl;
    }
    //operator重载，针对new重新作出一种解释,只针对当前类
    static void * operator new(size_t size)
    {
        objs++;
        cout << "new-call" << endl;
        myclass *p = ::new myclass;    //全局new
        return p;
    }
    static void operator delete(void *p)
    {
        objs--;
        cout << "delete-call" << endl;
        ::delete p;
    }
};
//功能1：无法在堆上被创建的类
void main()
{
    myclass *p1 = new myclass;
    myclass *p2 = new myclass;
    myclass *p3 = new myclass;
    delete p1;
 
    int *p = new int();    //此时new重载对于这一句无效
 
    cout << objs << endl;
 
    cin.get();
}

　　　　

#include <iostream>
using namespace std;
 
int objs = ;
void *g_p = nullptr;
 
class myclass
{
public:
    myclass()
    {
        //objs++;
        cout << "create" << endl;
    }
    ~myclass()
    {
        //objs--;
        cout << "delete" << endl;
    }
 
    //operator重载，针对new重新作出一种解释,只针对当前类
    static void * operator new(size_t size)
    {
        if (g_p==nullptr)
        {
            objs++;
            cout << "new-call" << endl;
            myclass *p = ::new myclass;    //全局new
            g_p = p;    //单例，堆上创建对象只有一个
            return p;
        }
        else
        {
            return g_p;
        }
    }
 
    static void operator delete(void *p)
    {
        if (g_p!=nullptr)
        {
            objs--;
            cout << "delete-call" << endl;
            ::delete p;
            g_p = nullptr;
        }
    }
};
//功能1：无法在堆上被创建的类
//功能2：实现统计分配内存，释放内存的次数
//实现单例设计模式，实现避免反复delete出错
//new delete在内部，只针对当前类，int double 无影响
void main()
{
    myclass *p1 = new myclass;
    myclass *p2 = new myclass;
 
    delete p1;
    delete p1;    //规避了两次delete的错误
 
    cin.get();
}

　　　　

2. 全局new,delete重载：

#include <iostream>
using namespace std;
 
//全局内存管理，统计释放内存，分配内存
//new        new []        delete        delete []
//分配内存优先于构造
//析构优先于释放内存
void * operator new(size_t size)
{
    cout << "g_new call" << endl;
    void *p = malloc(size);    //全局的new，只能使用malloc
    return p;
}
void * operator new [](size_t size)
{
    cout << "g_new [] call" << endl;
    cout << size << endl;
    return operator new(size);    //每个元素调用一次new
}
 
void operator delete(void *p)
{
    cout << "g_delete call" << endl;
    free(p);
}
void operator delete [](void *p)
{
    cout << "g_delete [] call" << endl;
    free(p);
}
 
class myclass
{
public:
    myclass()
    {
        cout << "create call" << endl;
    }
    ~myclass()
    {
        cout << "delete call" << endl;
    }
};
 
void main()
{
    int *p1 = new int();
    delete p1;
 
    myclass *p2 = new myclass;
    delete p2;
 
    myclass *px = new myclass[];
    delete[]px;
 
    cin.get();
}

　　　　

3. 绑定类成员函数：

#include <iostream>
#include <functional>
 
using namespace std;
using namespace std::placeholders;//站位
 
struct MyStruct
{
    void add1(int a)
    {
        cout << a << endl;
    }
    void add2(int a, int b)
    {
        cout << a << b << endl;
    }
    void add3(int a, int b, int c)
    {
        cout << a << b << c << endl;
    }
};
 
void main()
{
    MyStruct my1;
    //my1.add(10);
 
    //绑定包装器，包装类成员函数，用于使用
    auto fun1 = bind(&MyStruct::add1, &my1, _1);//有1个参数  函数名、对象地址、参数
    fun1();
 
    auto fun2 = bind(&MyStruct::add2, &my1, _1,_2);//有2个参数
    fun2(,);
 
    auto fun3 = bind(&MyStruct::add3, &my1, _1,_2,_3);//有3个参数
    fun3(,,);
 
    cin.get();
}

4. 绑定lambda表达式以及仿函数：

#include <iostream>
#include <functional>
 
using namespace std;
using namespace std::placeholders;
 
int add(int a, int b,int c)
{
    return a + b+c;
}
 
struct MyStruct
{
    int operator()(int a,int b)    //仿函数
    {
        return a + b;
    }
};
 
void main()
{
    auto fun1 = bind(add, ,, _1);//适配器模式
    cout << fun1() << endl;        //
 
    auto fun2 = bind([](int a, int b)->int {return a + b; }, , _1);
    cout << fun2() << endl;        //
 
    MyStruct my1;
    cout << my1(, ) << endl;        //
    auto fun3 = bind(my1, , _1);    //绑定
    cout << fun3() << endl;        //
 
    cin.get();
}

5. 静态断言：

#include <iostream>
#include <cassert>
using namespace std;
 
int divv(int a, int b)
{
    assert(b != );    //断言
    return a / b;
}
 
void main()
{
    cout << divv(, ) << endl;
 
    cin.get();
}

#include <iostream>
#include <cassert>
using namespace std;
 
static_assert(sizeof(void *) >= , "environment is not 64!");
 
void main()
{
 
    cin.get();
}

　　　　

6. 内联函数：

#include <iostream>
#include <cstdlib>
using namespace std;
 
#define f(x) x*x*x        //C语言内联，C++要求类型严格匹配
 
inline int get(int x)    //C++的内联函数
{
    return x*x*x;
}
//提高程序运行速度
 
//inline 只是对于编译器的建议
//一般情况下，我们对内联函数做如下的限制：
//（1）不能有递归；
//（2）不能包含静态数据；
//（3）不能包含循环；
//（4）不能包含switch和goto语句；
//（5）不能包含数组。
//若一个内联函数定义不满足以上限制，则编译系统把它当做普通函数对待
 
template<class T>
inline T go(T t)
{
    return t*t;
}
 
void main()
{
    get();
 
    go();    //优化为内联函数
 
    auto fun = []() {};    //lambda表达式实际上也是内联函数
 
    cin.get();
}

7. CPP处理转义字符：

#include <iostream>
#include <string>
#include <cstdlib>
 
using namespace std;
 
void main()
{
    //string str("\"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe\"");
    string str(R"("C:\Program Files (x86)\Google\Chrome\Application\chrome.exe")");            //  R"(......)" 
 
    system(str.c_str());
 
    cin.get();
}