此专栏为移动机器人知识体系下的编程语言中的$\mathrm{C}$++从入门到深入的专栏，参考书籍：《深入浅出$\mathrm{C}$++》(马晓锐)和《从$\mathrm{C}$到$\mathrm{C}$++精通面向对象编程》(曾凡锋等)。

---

---

10.模板与命名空间

10.1 模板简述

• 模板使函数和类的处理对象参数化，使代码具有通用性；

• $\mathrm{C}$++程序的组成单位是函数和类，因此，模板分为函数模板$(\mathrm{function}\mathrm{template})$和类模板$(\mathrm{class}\mathrm{template})$；定义模板后，可以处理不同的数据类型，不必显式定义针对不同数据类型的函数或类；

• 模板、函数模板、类模板与对象间的关系如下：

  

• 模板可以最大限度地实现代码重用，使代码精简；

10.2 函数模板

• 函数模板是一类可以被实例化的特殊函数，通过模板可以操作通用类型的数据，函数模板处理的数据类型是通过参数来体现，在函数模板实例化的过程中，才将这些参数具体化为一种特定的数据类型，因此，在定义函数时不用为每种数据类型都编写重复的相似代码；模板中表示数据类型的参数称为模板参数，这是一种特殊的参数，能传递一种数据类型；

• 声明函数模板参数类型的语法格式：

  // 声明格式1:
  template <class 类型标识符> 返回类型 函数名(函数形参表);
  
  // 声明格式2:
  template <typename 类型标识符> 返回类型 函数名(函数形参表);
  

  • $\mathrm{template}$是声明模板的关键字，表示声明一个模板;
  • $\mathrm{template}$关键字后是用尖括号’<>'括起来的类型参数表，类型参数表中包含一个或多个由逗号分隔的类型参数项，每一项由关键字$\mathrm{class}$和用户命名的标识符组成，此标识符为类型参数，不是一种数据类型，可以同一般数据类型一样使用在函数的任何地方；

• 调用函数模板的语法格式：

  函数名<具体类型>(参数表);
  

• 在调用函数模板时，<具体类型>可以省略，由系统自动判定；当<具体类型>不省略时，为显式实例化，当<具体类型>省略时，为隐式实例化；

• 函数模板接收参数类型问题：

  // 定义一个返回两个对象中较大对象的函数模板;
  // 下面的函数模板只能接收相同参数,不能接收两个不同的参数;
  // 因为只包含了一种类型的模板参数typename TheType;
  template <typename TheType>
  TheType GetMax(TheType a,TheType b)
  {
      return (a>b?a:b);
  }
  

  // 下面的函数模板可以接收两个不同类型的参数;
  template <typename TheType1,typename TheType2>
  TheType1 GetMax(TheType1 a,TheType2 b)
  {
      return (a>b?a:b);
  }
  

• 函数模板实例：定义一个操作数组的函数模板，完成遍历数组输出元素的功能$(example10\_1.cpp)$：

  /**
   * 作者：罗思维
   * 时间：2024/03/24
   * 描述：定义一个操作数组的函数模板，完成遍历数组输出元素的功能
   */
  #include <iostream>
  #include <string>
  
  using namespace std;
  
  // 定义函数模板;
  template <class T>
  void printArray(const T *array, const int count) {
  	for (int i = 0; i < count; i++) {
  		cout << array[i] << " ";
  	}
  	cout << endl;
  }
  
  int main() {
  	int nArray[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
  	char cArray[] = {'W', 'E', 'L', 'C', 'O', 'M', 'E'};
  
  	// 调用函数模板输出整型数组和字符数组中元素;
  	printArray(nArray, sizeof(nArray) / sizeof(int));
  	printArray(cArray, sizeof(cArray) / sizeof(char));
  	return 0;
  }
  

• 模板函数可以像普通函数一样被重载，实例如下$(example10\_2.cpp)$：

  /**
   * 作者：罗思维
   * 时间：2024/03/24
   * 描述：模板函数重载。
   */
  #include <iostream>
  #include <string.h>
  
  using namespace std;
  
  // 定义函数模板;
  template <typename TheType>
  TheType GetMax(TheType a, TheType b) {
  	return (a > b ? a : b);
  }
  
  // 重载函数模板,使函数模板支持字符串的处理;
  char* GetMax(char* a, char* b) {
  	return (strcmp(a, b) > 0 ? a : b);
  }
  
  int main() {
  	int nNumber1 = 10, nNumber2 = 20;
  	float fNumber1 = 13.14, fNumber2 = 5.20;
  
  	char a = 'L', b = 'C';
  	char *p1 = (char*)"C++";
  	char *p2 = (char*)"Python";
  
  	cout << "GetMax(10,20):" << GetMax(nNumber1, nNumber2) << endl;
  	cout << "GetMax(13.14,5.20):" << GetMax(fNumber1, fNumber2) << endl;
  
  	cout << "GetMax('L','C'):" << GetMax(a, b) << endl;
  	cout << "GetMax('C++','Python'):" << GetMax(p1, p2) << endl;
  
  	return 0;
  }
  

10.3 类模板

• 类模板的作用：将类所处理的对象类型参数化，它使得类中的某些数据成员的参数和返回值能取任意数据类型；

• 类模板定义的语法格式：

  template <类型参数表>
  class 类名
  {
      // 类体
  };
  

  • $\mathrm{template}$：声明模板的关键字，表示声明一个模板类；
  • <类型参数表>中包含一个或多个类型参数项，每一项由关键字$\mathrm{class}$和一个用户自定义的标识符组成，标识符为类型参数；
  • 使用类模板时，先将其实例化，即用实际的数据类型代替类型参数；
  • 当类模板中的成员函数在类定义体外定义时，必须被定义为一个函数模板的形式；

• 类模板实战项目$(\mathrm{classTemplate})$：

  • 项目需求：定义一个简单通用数组类模板，实现对一般数据类型数组的操作；

  • $\mathrm{CArray}$类定义头文件$(CArray.h)$：

    /**
     * 作者：罗思维
     * 时间：2024/03/25
     * 描述：CArray类定义头文件。 
     */
    #pragma once
    #include <iostream>
    #include <iomanip>
    #include <string.h>
    
    using namespace std;
    
    const int MIN_SIZE = 30;
    
    // 定义模板类 
    template <class T>
    class CArray {								// 数组类; 
    	protected:
    		T* m_pArray;						// 数组指针; 
    		int m_nSize;						// 数组元素个数; 
    	public:
    		CArray(int nSize, T Initial);		// 构造函数,初始化数组; 
    		~CArray() {							// 析构函数,释放内存; 
    			delete[] m_pArray;
    		};
    		T& operator[] (int nIndex) {		// 重载数组下标运算符; 
    			return m_pArray[nIndex];
    		};
    		void Show(const int nNumElems);		// 输出前nNumElems个元素; 
    		void Sort(int nNumElems);			// 将前nNumElems个元素进行排序; 
    };
    
    template <class T>
    CArray<T>::CArray(int nSize, T InitVal) {
    	m_nSize = (nSize > 1) ? nSize : 1;		// 保证nSize不小于1; 
    	m_pArray = new T[m_nSize];
    	for (int i = 0; i < m_nSize; i++) {
    		m_pArray[i] = InitVal;				// 将元素全部初始化为InitVal; 
    	}
    }
    
    template <class T>
    void CArray<T>::Show(const int nNumElems) {
    	for (int i = 0; i < nNumElems; i++) {
    		cout << m_pArray[i] << ' ';
    	}
    }
    
    template <class T>
    void CArray<T>::Sort(int nNumElems) {		// 对元素进行排序; 
    	int nOffset = nNumElems;
    	bool bSorted;
    	if (nNumElems < 2) {
    		return;
    	}
    	do {
    		nOffset = (nOffset * 8) / 11;
    		nOffset = (nOffset < 1) ? 1 : nOffset;
    		bSorted = true;
    		for (int i = 0, j = nOffset; i < (nNumElems - nOffset); i++, j++) {
    			if (m_pArray[i] > m_pArray[j]) {
    				T nSwap = m_pArray[i];
    				m_pArray[i] = m_pArray[j];
    				m_pArray[j] = nSwap;
    				bSorted = false;
    			}
    		}
    	} while (!bSorted || nOffset != 1);
    }
    

  • $\mathrm{CMyString}$类定义头文件$(CMyString.h)$：

    /**
     * 作者：罗思维
     * 时间：2024/03/25
     * 描述：CMyString类定义头文件。 
     */
    #pragma once
    #include "CArray.h"
    
    // 定义字符串类; 
    class CMyString {
    	protected:
    		char* m_pszString;					// 字符串指针; 
    		int m_nSize;						// 字符串中的字符个数; 
    	public:
    		CMyString(int nSize = MIN_SIZE) {
    			m_pszString = new char[m_nSize = nSize];
    		};
    		CMyString(const CMyString& CString);
    		CMyString(const char* pszString);
    		CMyString(const char cChar);
    		~CMyString() {
    			delete[] m_pszString;
    		};
    		int getLen() {
    			return strlen(m_pszString);
    		};
    		int getMaxLen() {
    			return m_nSize;
    		};
    
    		// 重载运算符= 
    		CMyString& operator=(const CMyString& aString);
    		CMyString& operator=(const char* pszString);
    		CMyString& operator=(const char cChar);
    
    		// 重载运算符> 
    		friend operator > (CMyString& aString1, CMyString& aString2) {
    			return (strcmp(aString1.m_pszString, aString2.m_pszString) > 0) ? 1 : 0;
    		}
    		friend ostream& operator << (ostream& os, CMyString& aString);
    };
    

  • $\mathrm{CMyString}$类实现文件$(CMyString.cpp)$：

    /**
     * 作者：罗思维
     * 时间：2024/03/25
     * 描述：CArray类实现文件。 
     */
    #include "CMyString.h"
    
    CMyString::CMyString(const CMyString &aString) {
    	m_pszString = new char[m_nSize = aString.m_nSize];
    	strcpy(m_pszString, aString.m_pszString);
    }
    
    CMyString::CMyString(const char *pszString) {
    	m_pszString = new char[m_nSize = strlen(pszString) + 1];
    	strcpy(m_pszString, pszString);
    }
    
    CMyString::CMyString(const char cChar) {
    	m_pszString = new char[m_nSize = MIN_SIZE];
    	m_pszString[0] = cChar;
    	m_pszString[1] = '\0';
    }
    
    CMyString &CMyString::operator=(const CMyString &aString) {
    	// 检查是否有足够的空间进行字符串的复制; 
    	if (strlen(aString.m_pszString) < unsigned(m_nSize)) {
    		strcpy(m_pszString, aString.m_pszString);
    	} else {
    		strncpy(m_pszString, aString.m_pszString, m_nSize - 1);
    	}
    
    	return *this;
    }
    
    CMyString &CMyString::operator=(const char *pszString) {
    	if (strlen(pszString) < unsigned(m_nSize)) {
    		strcpy(m_pszString, pszString);
    	} else {
    		strncpy(m_pszString, pszString, m_nSize - 1);
    	}
    
    	return *this;
    }
    
    CMyString &CMyString::operator=(const char cChar) {
    	if (m_nSize > 1) {
    		m_pszString[0] = cChar;
    		m_pszString[1] = '\0';
    	}
    
    	return *this;
    }
    
    // 输出对象重载; 
    ostream &operator << (ostream &os, CMyString &aString) {
    	os << aString.m_pszString;
    	return os;
    }
    

  • 程序主文件$(main.cpp)$：

    /**
     * 作者：罗思维
     * 时间：2024/03/25
     * 描述：程序主文件。 
     */
    #include <iostream>
    #include "CMyString.h"
    
    using namespace std;
    
    int main() {
    	const int MAX_ELEMS = 10;
    	int nArr[MAX_ELEMS] = {10, 20, 40, 50, 60, 90, 80, 70, 30, 100};
    	char cArr[MAX_ELEMS] = {'C', 'W', 'r', 'Y', 'k', 'J', 'X', 'Z', 'y', 's'};
    
    	CArray<int> IntegerArray(MAX_ELEMS, 0);			// 用int类型实例化通用数组类模板;
    	CArray<char> CharArray(MAX_ELEMS, ' ');			// 用char类型实例化通用数组类模板;
    	CArray<CMyString> StringArray(MAX_ELEMS, " ");	// 用自定义类型CMyString实例化通用数组类模板;
    
    	for (int i = 0; i < MAX_ELEMS; i++) {
    		IntegerArray[i] = nArr[i];
    	}
    
    	for (int i = 0; i < MAX_ELEMS; i++) {
    		CharArray[i] = cArr[i];
    	}
    
    	StringArray[0] = "GuangDong";
    	StringArray[1] = "BeiJing";
    	StringArray[2] = "HuBei";
    	StringArray[3] = "GuiZhou";
    	StringArray[4] = "GuangXi";
    	StringArray[5] = "HuNan";
    	StringArray[6] = "ShanDong";
    	StringArray[7] = "ShanXi";
    	StringArray[8] = "JiangSu";
    	StringArray[9] = "ZheJiang";
    
    	// 输出IntegerArray排序前后的内容;
    	cout << "Unsorted array is:" << endl;
    	IntegerArray.Show(MAX_ELEMS);
    	IntegerArray.Sort(MAX_ELEMS);
    	cout << "\nSorted array is:" << endl;
    	IntegerArray.Show(MAX_ELEMS);
    	cout << endl;
    
    	// 输出CharArray排序前后的内容;
    	cout << "Unsorted array is:" << endl;
    	CharArray.Show(MAX_ELEMS);
    	CharArray.Sort(MAX_ELEMS);
    	cout << "\nSorted array is:" << endl;
    	CharArray.Show(MAX_ELEMS);
    	cout << endl;
    
    	// 输出StringArray排序前后的内容;
    	cout << "\nUnsorted array is:" << endl;
    	StringArray.Show(MAX_ELEMS);
    	StringArray.Sort(MAX_ELEMS);
    	cout << "\nSorted array is:" << endl;
    	StringArray.Show(MAX_ELEMS);;
    
    	return 0;
    }
    

10.4 命名空间

• 命名空间是$\mathrm{ANSI}\mathrm{C}$++引入的可以由用户命名的作用域，用来处理程序中常见的同名冲突；

• $\mathrm{C}$++中的作用域有文件作用域、函数作用域、复合语句作用域和类作用域等，在不同的作用域中，定义具有相同名称的变量是合法的；

• 在文件中可以定义全局变量，作用域是整个程序，在同一个作用域中不应该出现两个或多个同名的实体；

• 在大型软件开发中，一般程序分模块完成，在各模块中可能会产生同名的实体，从而产生命名冲突；

• 如果引用标准库、第三方库、自定义库中包含与程序中定义的全局实体同名的实体，或不同库之间有同名的实体，则编译时出现命名冲突，称为全局命名空间污染$(\mathrm{global}\mathrm{namespace}\mathrm{pollution})$；

• 命名空间是由开发者命名的一个作用域区域，这些区域称为空间域，开发者可以根据需要指定一些有名称的空间域，把自定义的实体放在这个空间域中，保证使其与外界分离，这样可以使空间域内部实体不会与外界产生冲突；

• 命名空间定义的语法格式：

  namespace <命名空间名>
  {
      ...;	// 命名空间实体;
  }
  

  • $\mathrm{namespace}$：定义命名空间的关键字；
  • <命名空间名>：用户指定的命名空间的名称；
  • 大括号内是声明块，在其中声明的实体称为命名空间成员$(\mathrm{namespace}\mathrm{member})$，命名空间成员可以包含变量、常量、结构体、类、模板、命名空间等；

• 命名空间举例：

  namespace myns
  {
      int a;
      char c;
  }
  

  • 在程序中使用变量$\mathrm{a}、\mathrm{c}$，需要加上命名空间名和作用域限定符"$::$"，如：$\mathrm{myns}::\mathrm{a}、\mathrm{myns}::\mathrm{c}$，此用法称为命名空间限定$(\mathrm{qualified})$，$\mathrm{myns}::\mathrm{a}$称为被限定名$(\mathrm{qualified}\mathrm{name})$；

• 程序开发过程中，可以根据实际情况定义多个命名空间，把不同的库中的实体放到不同的命名空间中，即用不同的命名空间把不同的实体隐藏起来；

• 对命名空间成员引用的语法格式：

  命名空间::命名空间成员名
  

• 命名空间的几种使用方法：

  • 定义命名空间后，可以为其起一个别名:

    // 声明命名空间,名为:NameSpaceGraduateStudent;
    namespace NameSpaceGraduateStudent
    {
        ...;
    }
    
    // 给命名空间起别名;
    namespace NSGS=NameSpaceGraduateStudent;
    

  • 使用$\mathrm{using}$引入命名空间中的成员，$\mathrm{using}$的作用是引入命名空间或命名空间中的成员，其后面必须是由命名空间限定的名称；

    // 用using引入命名空间中的成员;
    // 引入后可以直接引用CStudent即可;
    using Stu::CStudent;
    
    // 等价关系;
    Stu::CStudent student ("Willard")	等价于		CStudent student ("Willard")
    

  • 使用$\mathrm{using}\mathrm{namespace}$引入命名空间，可以一次性引入命名空间的全部成员，语法格式：

    using namespace 命名空间名;
    

  • 无名的命名空间，在其他文件中无法使用，只能在本文件的作用域有效，语法格式：

    namespace
    {
        // 定义命名空间名;
        void func()
        {
            ...;
        }
    }
    

• 标准命名空间$\mathrm{std}$，在程序中没有引入标准命名空间时，要使用其中的成员，则使用$\mathrm{std}$来进行限定；

• $\mathrm{C}$++头文件的作用：为用户提供调用其实现的外部接口；

10.5 实战

项目需求：

约瑟夫$(\mathrm{Josephus})$问题：假设有$n$个小孩做成一个环，从第一个小孩开始数数，如果数到第$m$个小孩，则该小孩离开，问最后留下的小孩是第几个小孩？

问题分析：

如果总共有$6$个小孩，围成一圈，从第一个小孩开始，每次数$2$个小孩，则游戏情况过程：

小孩序号：$1、2、3、4、5、6$；

离开小孩序号：$2、4、6、3、1$；

则获胜小孩序号为：$5$；

代码实现$(\mathrm{Josephus})$：

• $JosephusRing.h$代码：

  /**
   * 作者：罗思维
   * 时间：2024/03/26
   * 描述：JosephusRing类定义头文件; 
   */
  #pragma once
  #include <iostream>
  #include <iterator>			// iterator：迭代器 
  #include <list>				// list是一个容器，其结构为双向链表;
  
  using namespace std;
  
  template <class Type>
  class JosephusRing {
  		list <Type> lst;
  
  	public:
  		class iterator;
  		friend class iterator;
  		class iterator: public std::iterator<std::bidirectional_iterator_tag, Type, ptrdiff_t> {
  				typename list<Type>::iterator it;
  				list<Type>* r;
  			public:
  				iterator(list<Type>& lst, const typename list<Type>::iterator& i): it(i), r(&lst) {};
  				bool operator==(const iterator& x) const {
  					return it == x.it;
  				};
  				bool operator!=(const iterator& x) const {
  					return !(*this == x);
  				};
  				typename list<Type>::reference operator*() const {
  					return *it;
  				};
  				iterator& operator++() {
  					++it;
  					if (it == r->end()) {
  						it = r->begin();
  					}
  					return *this;
  				};
  				iterator operator++(int) {
  					iterator tmp = *this;
  					++* this;
  					return tmp;
  				};
  				iterator& operator--() {
  					if (it == r->begin()) {
  						it = r->end();
  					}
  					--it;
  					return *this;
  				};
  				iterator operator--(int) {
  					iterator tmp = *this;
  					--*this;
  					return tmp;
  				};
  				iterator insert(const Type& x) {
  					return iterator(*r, r->insert(it, x));
  				};
  				iterator erase() {
  					return iterator(*r, r->erase(it));
  				};
  		};
  
  		void push_back(const Type& x) {
  			lst.push_back(x);
  		};
  
  		iterator begin() {
  			return iterator(lst, lst.begin());
  		};
  
  		int size() {
  			return lst.size();
  		}
  };
  

• 程序主文件$(main.cpp)$：

  /**
   * 作者：罗思维
   * 时间：2024/03/26
   * 描述：程序主文件。 
   */
  #include "JosephusRing.h"
  
  int main() {
  	int n, m;
  	cout << "请输入小孩总数:";
  	cin >> n;
  
  	cout << "每次数的孩子数:";
  	cin >> m;
  
  	JosephusRing<int> Josephus;
  	for (int i = 1; i <= n; i++) {
  		Josephus.push_back(i);
  	}
  
  	JosephusRing<int>::iterator tmp = Josephus.begin();
  	JosephusRing<int>::iterator it = tmp;
  
  	for (int index = 0; index < n - 1; index++) {
  		it = tmp;
  		for (int j = 0; j < m - 1; j++) {
  			it++;
  			tmp++;
  		}
  		tmp++;
  		cout << "离开的孩子:" << *it << endl;
  		it.erase();
  	}
  	it = Josephus.begin();
  
  	cout << "最后剩下的孩子:" << *it << endl;
  
  	return 0;
  }