【C/C++学院】0816-引用包装器/仿函数/转义字符 R”()”/using别名/模板元编程 比递归优化/智能指针/多线程/静态断言以及调试技能的要求 assert

//创建函数指针，类结构体，数据私有，代码共享 //函数通过调用，调用需要传递对象名进行区分 void(MyStruct::*p)(int ) = MyStruct::add; cin.get(); int main1() MyStruct struct1; //auto自动变量，地址，函数指针，bind绑定 //第一个参数引用内部函数，绑定一个实体对象， auto func = bind( MyStruct::add, struct1, _1);//一个参数 auto func2 = bind( MyStruct::add2, struct1,_1, _2);//二个参数 auto func3 = bind( MyStruct::add3, struct1, _1, _2,_3);//三个参数 func(100); func2(10, 20); func2(10, 20, 30);//只会接收前2个参数 func3(10, 20,30); cin.get(); return 0; } 转义字符 R”()”

#include iostream 

#include string 

#include stdlib.h 


 std::string path =R"( "C:\Program Files\Tencent\QQ\QQProtect\Bin\QQProtect.exe")";

 //R"()" 括号之间去掉转义字符

 system(path.c_str());

 system("pause");

}

using别名

#include iostream 


using FUNC = int (*)(int a, int b);//别名

using co = std::ios_base::fmtflags;//using只可以用于简写数据类型

void main()

 ADD p=add;

 std::cout p(1, 2) std::endl;

 FUNC func = add;

 std::cout func(1, 2) std::endl;

 //space::ptr int pint(new int(15));

 //std::cout *pint " " pint std::endl;

 std::cin.get();

模板元编程 比递归优化

#include iostream 

//模板元把运行时消耗的时间，在编译期间优化

template int N 

struct data

 enum {res =data N-1 ::res+data N-2 ::res};

template 

struct data 1 

 enum {res =1};

template 

struct data 2 

 enum {res= 1 };

//递归 斐波那契数列

//1 1 2 3 5 8

int getdata(int n)

 if (n==1 || n==2)

 return 1;

 else 

 return getdata(n - 1) + getdata(n - 2);

void main()

 const int myint = 40;

 int num = data myint ::res;// 内部不可以有变量

 std::cout num std::endl;

 std::cout getdata(40) std::endl;


//利用模板特化机制实现编译期条件选择结构，利用递归模板实现编译期循环结构，模板元程序则由编译器在编译期解释执行。

//优劣及适用情况

//通过将计算从运行期转移至编译期，在结果程序启动之前做尽可能多的工作，最终获得速度更快的程序。也就是说模板元编程的优势在于：

//1.以编译耗时为代价换来卓越的运行期性能（一般用于为性能要求严格的数值计算换取更高的性能）。通常来说，一个有意义的程序的运行次数（或服役时间）总是远远超过编译次数（或编译时间）。

//2.提供编译期类型计算，通常这才是模板元编程大放异彩的地方。

//模板元编程技术并非都是优点：

//1.代码可读性差，以类模板的方式描述算法也许有点抽象。

//2.调试困难，元程序执行于编译期，没有用于单步跟踪元程序执行的调试器（用于设置断点、察看数据等）。程序员可做的只能是等待编译过程失败，然后人工破译编译器倾泻到屏幕上的错误信息。

//3.编译时间长，通常带有模板元程序的程序生成的代码尺寸要比普通程序的大，

//4.可移植性较差，对于模板元编程使用的高级模板特性，不同的编译器的支持度不同。

#include iostream 

void main1()

 //auto_ptr;

 for (int i = 0; i 10000000; i++)

 double *p = new double;//为指针分配内存

 std::auto_ptr double autop(p);

 //创建智能指针管理指针p指向内存

 //智能指针 

 //delete p;

 std::cin.get();

}

C++11智能指针

#include iostream 

#include memory //内存

void main()

 for (int i = 0; i 10000000;i++)

 //新型指针，新型的数组 

 std::unique_ptr double pdb(new double);

 //double *p = new double;

 std::cin.get();

}

#include thread 

#include iostream 

#include windows.h 

#include vector 

using namespace std;

using namespace std::this_thread;

void msg()

 MessageBoxA(0, "12345", "678910", 0);

void msgA(int num)

 std::cout get_id() " num= " num std::endl;

void main1()

 // thread::hardware_concurrency线程

 auto n = thread::hardware_concurrency();

 std::cout n std::endl;

 //获取当前线程编号

 std::cout "thread=" get_id() std::endl;


  C++第十一节——单例模式 C++11 智能指针 异常 有关讲述 

 可以用同样的方式来实现，就是将构造函数私有化，然后让创建类的时候只能通过一个接口函数来实现，而在这个接口函数中我们将其创建在栈上。


  从C语言到C++你必须学会的---动态内存和智能指针 

 不管你是C++初学者，还是想从C语言转变为C++，你都应该了解C++的动态内存和智能指针，今天我们就来看一下有关这两个方面的内容。

本文章内容篇幅较长，且干货满满，感兴趣的大家可以收藏+点赞，以后慢慢看！


  【C++11】Smart Pointer 智能指针 

 首先看一个下面的栗子，左边是木有使用智能指针的情况，当执行foo()函数，其中的e指针会在bar(e)时传入bar函数，但是在bar函数结束后没有人为delete e时，就会导致内存泄漏；但是在右边的栗子中，使用了unique_ptr智能指针（single ownership），就能防止内存泄漏。