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

引用包装器   std::ref(变量)

#include<iostream>

template<class T>
void com(T arg)//模板函数，引用无效，引用包装器
{
	std::cout <<"com ="<< &arg << "\n";
	arg++;
}

void main()
{
	int count = 10;
	int  & rcount = count;
	com(count);
	std::cout << count << std::endl;
	//std::ref(变量) ，函数模板,引用包装器
	//com(std::ref(count));
	com(rcount);
	std::cout << "main=" << &rcount << "\n";
	std::cout << count << std::endl;

	std::cin.get();
}

仿函数

引用内部函数绑定机制

#include<iostream>
#include<functional>//处理函数

using namespace std;
using namespace std::placeholders;

//仿函数，创建一个函数指针，引用一个结构体内部或者一个类内部的公有函数
struct MyStruct
{
	void add(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 struct1;
	//创建函数指针，类结构体，数据私有，代码共享
	//函数通过调用，调用需要传递对象名进行区分
	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>


void main()
{
	std::string path =R"( "C:\Program Files\Tencent\QQ\QQProtect\Bin\QQProtect.exe")";
	//R"()"   括号之间去掉转义字符
 	system(path.c_str());
	system("pause");

}

using别名

#include <iostream>


namespace space   //隔离模板，避免冲突
{
	template<class T> using ptr = T*;//模板的简写
}

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

typedef  int(*ADD)(int a, int b);
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;
	

	std::cin.get();
}
//主要思想
//
//利用模板特化机制实现编译期条件选择结构，利用递归模板实现编译期循环结构，模板元程序则由编译器在编译期解释执行。
//
//优劣及适用情况
//
//通过将计算从运行期转移至编译期，在结果程序启动之前做尽可能多的工作，最终获得速度更快的程序。也就是说模板元编程的优势在于：
//
//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;


   thread thread1(msg);//创建多线程
   thread thread2(msg);
   thread1.join();//开始执行
   thread2.join();

	std::cin.get();
}

void main2()
{	 
	vector<thread *> threads;
	for (int i = 0; i < 10; i++)
	{
		threads.push_back(new thread(msg));//创建线程
	}

	for (auto th : threads)
	{
		th->join();
	}

	std::cin.get();
}

void main()
{
	vector<thread *> threads;
	for (int i = 0; i < 10; i++)
	{
		threads.push_back(new thread(msgA,i));//创建线程
	}

	for (auto th : threads)
	{
		th->join();
	}

	std::cin.get();
}

静态断言以及调试技能的要求 assert

#include <stdio.h>
#include<assert.h>
#include<iostream>

using namespace std;
#define  N 10

void main()
{
	int num = 100;
	cout << num << endl;
	cout << __FILE__ << endl;
	cout << __LINE__ << endl;
	cout << __DATE__ << endl;
	cout << __TIME__ << endl;
	cout << __FUNCTION__ << endl;

	cin.get();
}

#define M
void main1()
{
   char  num = 10;
   static_assert(sizeof(num) >= 1,"num valiued");

   assert(num >= 4,"num>4");
	//字节>4
#ifdef  M
  // static_assert(sizeof(num) >= 4, "yincheng error");
#endif
 
	//调试代码，迅速代码错误在哪一行
}

原文：http://blog.csdn.net/waldmer/article/details/48677337