C++模板的那丢丢事儿

最新推荐文章于 2022-04-12 14:53:49 发布
最新推荐文章于 2022-04-12 14:53:49 发布
阅读量208 收藏
点赞数
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KOwzb/article/details/115472563
版权

一、模板的引入

首先，请你认真思考一个问题，如何编写一个通用的加法函数呢？

1.对于我来说，首先第一反应是写一个宏函数来实现此功能，如：

#define ADD(x,y) ((x) + (y))

那么，这样写的缺点是什么呢？
（1）它没有参数检测，这个原因致使它能够完成该要求，同时也造就了它致命的缺陷，不能进行参数检测，故安全性不高。

（2）它不能像函数一样进行调试，而仅仅是在编译期间进行简单的参数替换，况且如果代码过长，会大幅增加代码量。

（3）宏函数可能会有副作用，在不该替换的时候进行替换，假设括号没加全。

（4）宏函数只能处理整数或枚举类型的数据，对于其他追加字符串，或其他外置类型的数据处理不了。

#include<iostream>
using namespace std;
 
#define ADD(x,y) ((x) + (y))
 
int main()
{
	cout<<ADD(1,3)<<endl;
	cout<<ADD(1.3,2.5)<<endl;
	cout<<ADD('A','G')<<endl;
    system("pause");
	return 0;
}

运行结果：

                            

错误证明：

                       

2、运用前面提到的函数重载解决通用加法函数，针对每个所需相同行为的不同类型重新实现它。

 

#include<iostream>
using namespace std;
 
int Add(const int &_iLeft, const int &_iRight)
{
	return (_iLeft + _iRight);
}
float Add(const float &_fLeft, const float &_fRight)
{
	return (_fLeft + _fRight);
}
 
int main()
{
	cout<<Add(1,3)<<endl;
	cout<<Add(1.3f,2.5f)<<endl;
    system("pause");
	return 0;
}

运行结果：

              

这种方法的缺点：

（1）只要有新类型出现，就要重新添加对应函数。
（2）除类型外，所有函数的函数体都相同，代码的复用率不高
（3）如果函数只是返回值类型不同，函数重载不能解决
（4）一个方法有问题，所有的方法都有问题，不好维护。

3、通过多态实现，使用公共基类，将需要用到的虚函数代码放在公共的基础类里面，通过基类的对象指针进行调用，派生类可重写也可不重写。

class B
{
public:
      virtual int add(int _x,int _y)
	  {
	     return (_x+_y);
	  }
	  virtual float add(float _x,float _y)
	  {
	     return (_x+_y);
	  }
};
class INT_ADD:public B
{};
class FLOAT_ADD:public B
{};
 
int main()
{
	B *b;
	INT_ADD i;
	FLOAT_ADD f;
	
	b = &i;
	cout<<b->add(1,3)<<endl;
	b = &f;
	cout<<b->add(1.8f,3.6f)<<endl;
	
	system("pause");
	return 0;
}

缺点：

（1）借助基类虚函数来编写适合各种类型的加法函数，只要有新类型出现，就要重新添加对应函数，代码利用率不高；

（2）对于以后实现的许多派生类，都必须调用各自某个特定的基类虚函数，代码维护更加困难

4、通过模板解决。

 模板的分类：模板分为函数模板和类模板，他们分别允许用户构造模板函数和模板类。

既然上面的几种方法都有各自的缺陷，于是就引入了模板的概念，使用我们的模板解决上述问题，那将是最好不过了，下面用函数模板实现通用加法函数。

template <typename T>
T ADD(T x,T y)
{
	return (x+y);
}
int main()
{
	cout<<ADD(1,3)<<endl;
	cout<<ADD(1.3,2.5)<<endl;
	system("pause");
	return 0;
}

优点：利用模板机制可以显著减少冗余信息，能大幅度的节约程序代码，进一步提高面向对象程序的可重用性和可维护性。

二、函数模板

函数模板：

      所谓函数模板，实际上是建立了一个通用函数，其函数返回类型和形参类型不具体指定，用一个虚拟的类型来代表，这个通用函数就称为函数模板（注意它不是真正的函数）。代表了一个函数家族，该函数与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

（一）函数模板声明的一般格式：

（二）函数模板的使用

（1）模板函数的实例化：

 当我们调用一个函数模板时，编译器（通常）用函数实参来为我们推断模板实参，此模板实参来为我们实例化一个特定版本的函数。当编译器实例化一个模板时，它使用实际的模板实参代替对应的模板参数来创建模板的一个新“实例”，此过程称为模板的实例化

函数模板的实例化有两种调用方式，即显式实例化和隐式实例化。

 

template <typename T>
T ADD(T x,T y)
{
	return (x+y);
}
int main()
{
	cout<<ADD(1,3)<<endl;//隐式实例化
	cout<<ADD<float>(1.3f,2.5f)<<endl;//显式实例化
	system("pause");
	return 0;
}

自定义类型不能直接用模板函数进行实例化，除非自己实现重载。

注意：模板被编译了两次：

a>实例化之前，检查模板代码本身，查看是否出现语法错误，如：遗漏分号

b>在实例化期间，检查模板代码，查看是否所有的调用都有效，如：实例化类型不支持     某些函数调用

（2）模板函数的使用规则

a>模板函数也可以定义为内联函数

template <typename T>
inline T ADD(T x,T y)
{
	return (x+y);
}

注意：inline关键字必须放在模板形参表之后，返回值之前，不能放在template之前

b>模板函数的不足之处：不能自动进行类型转换，由于需要生成代码，所以编译速度慢

                    

要解决上述类型不同的问题，有以下三种方法：

1，采用显式实例化方式

template <typename T>
T ADD(T x,T y)
{
	return (x+y);
}
int main()
{
    cout<<ADD<int>(1,'d');
	system("pause");
	return 0;
}

2，将其中一个参数进行强制类型转换

template <typename T>
T ADD(T x,T y)
{
	return (x+y);
}
int main()
{
    cout<<ADD(1,(int)'d');
	system("pause");
	return 0;
}

3，多带一个参数模板（在类型中允许使用多个类型参数）

template <typename T,typename G>
T ADD(T x,G y)
{
	return (x+y);
}
int main()
{
    cout<<ADD(1,'d');
	system("pause");
	return 0;
}

d>模板参数

<1>【实参推演】
       从函数实参确定模板形参类型和值的过程称为模板实参推断,即函数模板实例化过程中，编译器用函数实参来为我们推断模板实参的过程。

注意：多个类型形参的实参必须完全匹配

<2>【类型形参转换】

编译器只会执行两种转换：
1、const转换：接收const引用或者const指针的函数可以分别用非const对象的引用或者指针来调用。

template <typename T>
 T ADD(const T& x,const T& y)
{
	return (x+y);
}
int main()
{
	int a = 10;
	int b = 20;
	int &ra = a;
	int &rb = b;
	
	cout<<"a + b ="<<ADD(ra,rb)<<endl;
	system("pause");
	return 0;
}

2、数组或函数到指针的转换：如果模板形参不是引用类型，则对数组或函数类型的实参应用常规指针转换。数组实参将当做指向其第一个元素的指针，函数实参当做指向函数类型的指针。

template <typename T>
T ADD(const T* x,const T* y)
{
	return (*x + *y);
}
int main()
{
	int a[5] = {0};
	int b[5] = {5,4,3,2,1};
	cout<<"a + b = "<<ADD(a,b)<<endl;
	system("pause");
	return 0;
}

<3>模板参数的分类

函数模板有两种类型参数：模板参数和调用参数

模板形参：类型形参和非类型形参

 

模板形参名字只能在模板形参之后到模板声明或定义的末尾之间使用，遵循名字屏蔽规则，即我们常用的就近原则。

typedef int T;//将int类型重命名为T
 
template <typename T>//函数模板
void Funtest(T t)
{
	cout<<"t type = "<<typeid(t).name()<<endl;//打印形参t的类型
}
 
T gloab;//定义全局变量gloab
 
int main()
{
	Funtest(10);
	cout<<"gloab type = "<<typeid(gloab).name()<<endl;
	system("pause");
	return 0;
}

代码分析：

总结：

模板形参说明
1、模板形参表使用<>括起来
2、和函数参数表一样，跟多个参数时必须用逗号隔开，类型可以相同也可以不相同
3、模板形参表不能为空
4、模板形参可以是类型形参，也可以是非类型新参，类型形参跟在class和typename后
5、模板类型形参可作为类型说明符用在模板中的任何地方，与内置类型或自定义类型
使用方法完全相同，可用于指定函数形参类型、返回值、局部变量和强制类型转换
6、模板形参表中，class和typename具有相同的含义，可以互换，使用typename更加直观。
但关键字typename是作为C++标准加入到C++中的，旧的编译器可能不支持。
e>函数模板的重载

1、同一般函数一样，函数模板也可以重载。

template<typename T>
T Max(const T& left, const T& right)
{
	return left>right? left:right;
}
template<typename T>
T Max(const T& a, const T& b, const T& c)
{
	return Max(Max(a, b), c);
};
int main()
{
cout<<Max(1,2)<<endl;
cout<<Max(1.2,3.4,5.6)<<endl;
system("pause");
return 0;
}

2、模板函数与同名的非模板函数可以重载。   

       在这种情况下，函数的调用顺序是：首先寻找一个参数完全匹配的非模板函数，如果找到了就调用它此种情况下，编译器并不会为相应的函数模板产生匹配的模板函数，如果想让编译器为模板函数生成代码，则必须显示实例化，且生成的代码与普通函数不是同一份代码；若没有找到参数完全匹配的非模板函数，则寻找函数模板，将其实例化产生一个匹配的模板函
 

int Max(const int& left, const int & right)//普通函数
{
	return left>right? left:right;
}
template<typename T>
T Max(const T& left, const T& right)
{
	return left>right? left:right;
}
template<typename T>
T Max(const T& a, const T& b, const T& c)
{
	return Max(Max(a, b), c);
};
int main()
{
	cout<<Max(10, 20, 30)<<endl;
	cout<<Max<>(10, 20)<<endl;
	cout<<Max(10, 20)<<endl;
	cout<<Max(10, 20.12)<<endl;
	cout<<Max<int>(10.0, 20.0)<<endl;
	cout<<Max(10.0, 20.0)<<endl;
	system("pause");
	return 0;
}

注意：函数的所有重载版本的声明都应该位于该函数被调用位置之前。

【说明】
1、一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例
化为这个非模板函数。
2、对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调动非模板
函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，
那么将选择模板。
3、显式指定一个空的模板实参列表，该语法告诉编译器只有模板才能来匹配这个调用，
而且所有的模板参数都应该根据实参演绎出来。
4、模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

f>模板函数特化

1、定义：

有时候并不总是能够写出对所有可能被实例化的类型都最合适的模板，在某些情况下，通用模板定义对于某个类型可能是完全错误的，或者不能编译，或者做一些错误的事情,这时候就需要对模板函数进行特化（即具体化）。

template <typename T>
int Compare(T s1, T s2) 
{
	if(s1<s2)
		return -1;
	else if(s1>s2)
		return 1;
	else 
		return 0;
}
int main()
{
	char* str1 = "abcd";
	char* str2 = "ghf";
	cout<<Compare(str1,str2)<<endl;
	system("pause");
	return 0;
}

 

template <typename T>
int Compare(T s1, T s2) 
{
	if(s1<s2)
		return -1;
	else if(s1>s2)
		return 1;
	else 
		return 0;
}
template<>//模板函数的特化
int Compare<const char*>(const char* s1,const char* s2)
{
	return strcmp(s1,s2);
}
int main()
{
	const char* str1 = "abcd";
	const char* str2 = "ghf";
	cout<<Compare(str1,str2)<<endl;
	system("pause");
	return 0;
}

 

2、模板函数特化形式如下：

1>关键字template后面接一对空的尖括号<>
2>再接模板名和一对尖括号，尖括号中指定这个特化定义的模板形参
3>函数形参表
4>函数体
template<>
返回值 函数名<Type>(参数列表)
{
     // 函数体
}

其次，需要注意的是给函数模板传参时一定要与特化参数列表中的参数格式一模一样，否则有可能即使写了特化，运行过程中也不会调用

template <typename T>
int Compare(T s1, T s2) 
{
	if(s1<s2)
		return -1;
	else if(s1>s2)
		return 1;
	else 
		return 0;
}
template<>//模板函数的特化
int Compare<const char*>(const char* s1,const char* s2)//注意参数类型为const char*
{
	return strcmp(s1,s2);
}
int main()
{
	char* str1 = "abcd";//定义实参类型为char*
	char* str2 = "ghf";//定义实参类型为char*
	cout<<Compare(str1,str2)<<endl;
	system("pause");
	return 0;
}

  

注意：

1.在模板特化版本的调用中，实参类型必须与特化版本函数的形参类型完全匹配，
如果不匹配，编译器将为实参模板定义中实例化一个实例。

2.特化不能出现在模板实例的调用之后，应该在头文件中包含模板特化的声明，然

后使用该特化版本的每个源文件包含该头文件。

三、类模板

 

与函数模板类似，模板类也是模板，必须以关键字template开头，后接模板形参表。

【普通顺序表】

【模板类格式】
template<class 形参名1, class 形参名2, ...class 形参名n>
class 类名
{ ... };

template<typename T>
class SeqList
{
private :
T* _data ;
int _size ;
int _capacity ;
};

 

// 以模板方式实现动态顺序表

template<typename T>
class SeqList
{
public :
SeqList();
~ SeqList();
private :
int _size ;
int _capacity ;
T* _data ;
};
template <typename T>
SeqList <T>:: SeqList()
: _size(0)
, _capacity(10)
, _data(new T[ _capacity])
{}
template <typename T>
SeqList <T>::~ SeqList()
{
delete [] _data ;
}
void test1 ()
{
SeqList<int > sl1;
SeqList<double > sl2;
}

【模板类的实例化】
只要有一种不同的类型，编译器就会实例化出一个对应的类。

SeqList<int > sl1;
SeqList<double > sl2;

  1. 当定义上述两种类型的顺序表时，编译器会使用int和double分别代替模板形参，重新编写SeqList类，最后创建名为SeqList<int>和SeqList<double>的类

 

【非类型的类模板参数】

// 静态顺序表
//template<typename T, size_t MAX_SIZE>
template <typename T, size_t MAX_SIZE = 10> //带缺省模板参数
class SeqList
{
public :
SeqList();
private :
T _array [MAX_SIZE];
int _size ;
};
template <typename T, size_t MAX_SIZE>
SeqList <T, MAX_SIZE>::SeqList()
: _size(0)
{}
void Test()
{
SeqList<int> s1;
SeqList<int , 20> s2;
}

注意：浮点数和类对象是不允许作为非类型模板参数的

【类模板的特化】

全特化

template <typename T>
class SeqList
{
public :
	SeqList();
	~ SeqList();
private :
	int _size ;
	int _capacity ;
	T* _data ;
};
template<typename T>
SeqList <T>:: SeqList()
	: _size(0)
	, _capacity(10)
	, _data(new T[ _capacity])
{
	cout<<"SeqList<T>" <<endl;
}
template<typename T>
SeqList <T>::~ SeqList()
{
	delete[] _data ;
}
template <>
class SeqList <int>
{
public :
	SeqList(int capacity);
	~ SeqList();
private :
	int _size ;
	int _capacity ;
	int* _data ;
};

// 特化后定义成员函数不再需要模板形参

SeqList <int>:: SeqList(int capacity)
: _size(0)
, _capacity(capacity )
, _data(new int[ _capacity])
{
cout<<"SeqList<int>" <<endl;
}

偏特化（局部特化）

template <typename T1, typename T2>
class Data
{
public :
	Data();
private :
	T1 _d1 ;
	T2 _d2 ;
};
template <typename T1, typename T2>
Data<T1 , T2>::Data()
{
	cout<<"Data<T1, T2>" <<endl;
}
// 局部特化第二个参数
template <typename T1>
class Data <T1, int>
{
public :
	Data();
private :
	T1 _d1 ;
	int _d2 ;
};
template <typename T1>
Data<T1 , int>::Data()
{
	cout<<"Data<T1, int>" <<endl;
}

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限
制所设计出来的一个特化版本。

// 局部特化两个参数为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public :
Data();
private :
T1 _d1 ;
T2 _d2 ;
T1* _d3 ;
T2* _d4 ;
};
template <typename T1, typename T2>
Data<T1 *, T2*>:: Data()
{
cout<<"Data<T1*, T2*>" <<endl;
}
// 局部特化两个参数为引用
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public :
Data(const T1& d1, const T2& d2);
private :
const T1 & _d1;
const T2 & _d2;
T1* _d3 ;
T2* _d4 ;
};
template <typename T1, typename T2>
Data<T1 &, T2&>:: Data(const T1& d1, const T2& d2)
: _d1(d1 )
, _d2(d2 )
{
cout<<"Data<T1&, T2&>" <<endl;
}
void test2 ()
{
Data<double , int> d1;
Data<int , double> d2;
Data<int *, int*> d3;
Data<int&, int&> d4(1, 2);
}

模板的全特化和偏特化都是在已定义的模板基础之上，不能单独存在。

【模板的分离编译】

解决办法：
1. 在模板头文件 xxx.h 里面显示实例化->模板类的定义后面添
加 template class SeqList<int >; 一般不推荐这种方法，一方面老编译器可能不支持，另一方
面实例化依赖调用者。（不推荐）
2. 将声明和定义放到一个文件 "xxx.hpp" 里面，推荐使用这种方法。


模板总结
【优点】
模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。
增强了代码的灵活性。
【缺点】
模板让代码变得凌乱复杂，不易维护，编译代码时间变长。
出现模板编译错误时，错误信息非常凌乱，不易定位错误。
 

KOwzb
关注
专栏目录
C++ STL 标准模板库介绍与入门
dvlinker的技术专栏
05-14 2万+
C++ STL 标准模板库概述与入门
C++模板元编程（11）模板全特化和偏特化
二进制君
05-15 5501
文章目录1、C++模板2、C++模板全特化3、C++模板偏特化4、模板类调用优先级 1、C++模板 大家都对C++的模板编程应该都能很熟练使用了，下面就是一段很简单不过的例子了 //模板函数 template<typename T1, typename T2> void func(T1 num1, T2 num2) { } //模板类 template<typename T1, typename T2> class Test { void func(T1 a,T2 b)
模板的那丢丢事儿
snow_5288的博客
11-08 4769
注意：以下所有代码均在VS2010环境下调试运行 模板的引入，函数模板，类模板的实例化、重载、特化等详解。
C++模板的局限性
Lan的博客
10-14 295
问题：当模板中传入数组或者自定义的数据类型时，模板无法实现 解决办法：C++为了实现这个功能，提供了模板重载，为这些类型提供具体化的类模板 模板示例： template<class T> bool Compare(T a,T b) { //当输入的参数T类型是数组或自定义的Person类型时，无法的得到预期的结果 if(a=b) { return true; } else { return false;
C++中的模板功能介绍
Vergesson
03-01 1919
.前言 C++中的模板分为函数模板和类模板。 在C++中，模板允许我们处理问题的逻辑从不同的数据类型中抽离出来，形成容器和算法。 当我们需要对某种数据进行存取和处理的时候，我们可以在程序中，选择合适的模板指定我们需要的数据类型，这个时候，编译器就会为我们生成适合这种类型的容器和算法函数。 .函数模板 1、情景 多个一样或几乎完全一样的重载函数体带来的问题不仅是冗余，还有就是当你打算修改算法的时候，如果你没有在各个函数体里进行同步修改的话，还会造成在同一系统中，处理同类型的问题，用的算法不一致，导致不一致性的
C++模板的局限性 模板的局限性
qq_36711295的博客
08-11 221
C++模板的局限性 模板的局限性 局限性： 模板的通用性并不是万能的 例如： template<class T> void f(T a, T b) { a = b; } 在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了 再例如： template<class T> void f(T a, T b) { if(a > b) {} } 在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行 因此C++为了解决这种问题，
类模板深度分析 多参数 重定义 特化
weixin_42173948的博客
06-28 337
类模板可以定义任意多个不同类型的参数 类模板可以被特化 指定类模板的特定实现 部分类型参数必须显示指定 根据数据结构参数分开实现类模板 类模板的特化类型 部分特化 – 用特定规则约束类型参数 完全特化–完全特化显示指定类型参数 #include <iostream> #include <string> using namespace std; template <typename T1, typename T2 > class Test { public
基于OpenCV的的图像旋转匹配算法模板（C++实现）
01-02
1.基于OpenCv的旋转匹配 基于OpenCv实现了模板图像的旋转匹配，此代码基于matchTemplate函数...2.带旋转的模板匹配的原理及算法实现(c++) 带旋转的模板匹配算法，能够匹配带旋转角度的模板。（VS 2015+OPENCV C++）
c++模板编程
习惯有你
12-13 3290
模板引入 模板主要是用来解决类库与类库使用不是一个人，编写类库时，不能确定使用类库的人会传入什么类型的数据，而做的一个类型抽象，编译器根据具体调用类库的时候，调用者传入的参数自动推导出数据类型，来替换类库中的数据类型。template关键字定义一个模板，typename关键字指定模板类型抽象名称。示例如下： template<typename T> void myswp(T &a,T &b) //交换数据 { T temp; temp=a; ...
c++ 定义模板
m0_56077202的博客
04-12 1597
定义模板 当定义一个比较函数时，因为参数类型包括int、float、char等等，若为每个类型都定义一个比较函数，就不得不重复定义完全一样的函数体，并且需要确定要比较的所有类型，就比较麻烦了。 函数模板 ： 以关键字开始 加一个模板参数列表 template <typename T> 这样就可以定义一个通用的函数模板，而不是为每一数据类型都定义一个新函数 template <typename T> int compare(const T &v1,const T &v
C++-函数模板特化如何避免重复定义
shellching的专栏
11-28 6032
本文转自：https://www.cnblogs.com/dracohan/p/3401660.html  转来收藏以便查阅，感谢原作者 另一篇相关博文：https://blog.csdn.net/shixin_0125/article/details/78778234 我正在用一个基于模板的库源代码，该库包含一些针对特定类型的模板函数特化。类模板，函数模板和模板函数特化都在头文件中。我在我的...
27.内联函数
augfun的博客
08-07 155
内联函数是空间换时间 在c++中，预定义宏的概念是用内联函数来实现的，而内联函数本身也是一个真正的函数。内联函数具有普通函数的所有行为。唯一不同之处在于内联函数会在适当的地方像预定义宏一样展开，所以不需要函数调用的开销。因此应该不使用宏，使用内联函数。 为了定义内联函数，通常必须在函数定义前面放一个inline关键字。但是在类内部定义内联函数时并不是必须的。任何在类内部定义的函数自动成为内联函...
C++模板总结
我的CSDN
04-27 654
C++模版特化总结： 文章参考了http://www.cppblog.com/SmartPtr/archive/2007/07/04/27496.html // general version template class Compare { public:     static bool IsEqual(const T& lh, const T& rh)  
global关键字（在局部作用域中声明使用全局变量）
weixin_46521335的博客
05-27 2321
简介：globle的英语解释是球的意思它的作用是把在局部作用用域中声明全局变量，我们在定义函数时常常会遇到需要使用全局变量的情况，这时候我们就可以使用它 代码例子： #python中规定m是全局变量，它在当前python文件中都能被访问 m = 1 def foo (): # 函数和类会内部会形成一个局部作用域，函数和类当中是不能直接使用全局变量的 m=10 print('函数foo内m的值：',m) if __name__ == '__main__': prin.
c++函数模版，调试过程
Pu_wj的博客
05-15 625
using namespace std; template<typename T> T max(T& a,T& b){ return (a>b)?a:b; } int main(int argc, const char * argv[]){ int i1=1,i2=3; double d1=3.298,d2=8.343; char c1='a',c2='b'; cout<<max(d1,d2)<<' '<
C++ Global(static) Object - Problems
SJcinux Blog
07-23 2886
C++中静态对象的3种类型：1、   函数范围内的静态变量；2、   全局和名字空间范围的静态变量也被称为非局部静态变量；3、   静态成员变量指那些在它们所属类的所有实例之间共享的变量。全局（静态）对象放置于可执行文件的.data(.bss)段，该节被简单地拷贝到可读写的内存段。但是C++未提供控制全局（静态）对象的顺序的机制。  在一个给定的单元内，全局对象的生命期
Ubuntu16.04LTS +Qt+boost1.66编译错误：consuming_buffers.hpp: parse error in template argument list...
weixin_30561425的博客
05-07 1014
升级gcc版本至 6 以上.. 安装gcc-6系列与安装boost （Ubuntu16.04LTS) 转载于:https://www.cnblogs.com/zhehan54/p/9003184.html
c++ 模板
晓东的博客
11-04 3733
c++    模板 在编程中  ，我们经常会遇到一些通用函数 。。。。 要通过这个函数来实现不同的参数的函数的调用 。。。 之前在C++中我们学习了 函数的重载 来解决这个问题 。。。 但是函数重 载要对每一种情况都要进行编写 。。。。并且函数重载对返回值不同的两个函数不能构成重载。。 除了函数重载我们还可以使用公共基类来解决这个问题 。。。。  如果 使用一个公共的基础
C++模板元编程入门与实践
“C++模板元编程 ppt - 荣耀：深入探讨了C++模板元编程的历史、概念、应用及其实现方法。” C++模板元编程（Template Metaprogramming，简称TMP）是一种利用C++模板系统进行编译时计算的技术。通过这种方式，程序员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值