模板

使用Templates（模板）来生成不同的代码块，函数和类。 每个模板使用template关键字来启动并设置标识符及代码块，函数或类。在使用模板时，标识符会被这些设置所取代。

应使用模板而不应使用#define预处理指令。 #define的主要不同之处在于：

• 模板支持语法凸显。
• 模板相对于作用域进行工作scope （而#define具有全局作用域）。

See Also可参看#

用来生成代码块的模板所遵循的语法如下：

template template_name<ARG_NAME> { 
	code_chunk
}

template print<STRING,DIGIT> {
	log.message("%s, ",STRING);
	log.message("%d\n",DIGIT);
}

// 生成一个代码块
print<typeinfo(12),17>;
print<"12",17>;

// 生成下列代码：
// log.message("%s, ","int: 12");
// log.message("%d\n",17);
// log.message("%s, ","12");
// log.message("%d\n",17);

要将模板参数转换成字符串类型，需在参数之前使用#：

template print<DIGIT> {
	log.message("%d\n",DIGIT);
	log.message("text_%s",#DIGIT);
}

print<17>;

// 输出为：
// 17
// text_17

当然也可以创建一个模板用来生成函数而不是代码块。 此函数会取代由模板设置的标识符。函数模板的语法如下：

template template_name<ARG_NAME> void ARG_NAME { 
	function_code
}

要在一个模板中声明数个函数，仅需将函数放在花括号中：

template template_name<ARG_NAME> { 
	void func1_ ## ARG_NAME { function_code; }
	void func2_ ## ARG_NAME { function_code; }
}

下方的实例演示如何：

• 使用3个参数声明模板并从模板中生成函数：
  源代码 (UnigineScript)

  template sum_template<NAME,A0,A1> void NAME() {
  	log.message("%s\n",typeinfo(A0 + A1));
  }
  
  // 生成sum()函数，此函数将1 与 2相加
  sum_template<sum,1,2>;
  // 调用生成的函数
  sum();
  
  // 输出为： int: 3

• 在一个模板中声明数个函数并在代码中使用此模板来生成类的成员函数：
  源代码 (UnigineScript)

  template setget<TYPE,NAME,VALUE> {
  	void set ## NAME(TYPE v) { VALUE = v; }
  	TYPE get ## NAME() { return VALUE; }
  }
  			
  class Foo {
  	int a,b,c;
  	// 生成下列函数：
  	// void setA(int v) { a = v; }
  	// int getA() { return a; }
  	setget<int,A,a>;
  	// void setB(int v) { b = v; }
  	// int getB() { return b; }
  	setget<int,B,b>;
  	// void setC(string v) { c = v; }
  	// string getC() { return c; }
  	setget<string,C,c>;
  	void info() { log.message("%d %d %s\n",a,b,c); }
  };
  
  Foo f = new Foo();
  // 调用生成的成员函数
  f.setA(12);
  f.setB(13);
  f.setC("Sample string");
  f.info();
  
  // 输出为： 12 13 Sample string

用来生成类的模板语法如下：

template template_name<ARG_NAME> {
	class ARG_NAME {
		class_members
	};
}

template my_class<NAME> {
    class My ## NAME {
        My ## NAME() {
            log.message(__FUNC__ + ": called\n");
        }
        ~My ## NAME() {
            log.message(__FUNC__ + ": called\n");
        }
    };
}

// 生成Foo类
my_class<Foo>;

MyFoo f = new MyFoo();
delete f;