C++根据头文件自动生成实现文件框架（支持模版）

　　以前写了一个，也贴出来了不过对模版支持不好，不带模版的函数和类成员函数还是支持的。

   

  　最近写模版类的头文件，而模版类的话如果不想inline在外部实现的化，书写起来格式很麻烦。尤其是如果返回变量的类型是在类内部typedef的类型。

　　所以对以前的程序修改了以下，还是利用Python正则表示生成对应的实现文件，对于模版类其实也可以生产.cc文件的将函数的实现写在.cc文件中，

　　如在MeshT.h文件的最后include的实现文件MeshT.cc就可以了（Openmesh就是这么做的,下面有例子），

　　这样避免代码都写在.h中比较乱，而且头文件太长。

　　嗯，现在的h2cc.py基本能完成要求，可能有些特殊情况会出问题，待验证，另外代码有多个地方重复的地方待整理。

      下一步要做的，

　　1.进一步测试对各种情况正确无误，包括更复杂的模版测试，

      2.当前完全按照格式处理，不考虑语义理解，所以对于SGI STL源代码那样头文件中把函数返回变量单独写一行的无法处理。这个以后有好的办法再处理。

       （感觉做编译器的完全能写个.h到.cc的自动转换工具为啥我搜不到呢，还得自己写....肯定不如人家的精确）

      3. 当前如果存在生成文件了已经，比如用户开始生成了.cc然后又在.h中增加方法，再次生成.cc的时候我会将新的方法统一写在原来.cc文件的最后，具体合适

          的位置用户再改动。 下一步考虑自动将新的方法插入到原来.cc文件的合适位置,不过用户如果改动如函数格式，nameapce名称，新添加namespace等等肯定会带来问题

          那个用户自己处理吧(注意这里的.cc文件都是按照h2cc.py生成） 

      4.像java或者python那样，将所有的代码都写到一起，即不存在头文件的写法，这样代码写起来更方便。对于C++代码可以全部写到.h中。然后调用转换

          工具，自动生成.cc文件，将所有没有声明inline的函数并且实现代码长度超过n行的（如10行）自动在.h中转换为声明格式，在.cc中写成实现格式

          并把实现代码拷贝过去，

          可以用户紧挨函数在上面一行开头加注释如//*标明下面的函数不做转换处理在.h中inline。

          个人觉得这样还是能提高写程序的效率的，不知道现在有没有现成的转换工具。

       5.要做上面的工作需要对代码修改，当前的代码可扩充性太差....，扩展功能麻烦，首先把各个重复的地方提前出来统一处理。如去掉=的模式。

          试图写子函数，但是问题是我需要对每一行代码做太多的情形分析，这样while循环太长了，又不好分子程序，

          尤其是 python不支持类似c++的引用，写子函数修改输入变量如输入行号i并在子函数中修改，用Python还得返回i才行，别扭：（ 

          嗯，最后决定暂时就这样了，程序不改了，当前的做法对于{}的处理采用统一忽略的做法包括类似if abc() {}的处理，修改实现其它的功能比较麻烦。。。 

//h2cc.py

   1 #!/usr/local/bin/python3.1 

  2 #file    h2cc.py
  3 #author  pku_goldenlock@qq.com
  4 #date    2009-10-23 18:19:38.970028
  5 
  6 #.h convert to .cpp framework
  7 #注意!!
  8 #1. 我们假定你的.h代码书写正确 当前不做异常，错误处理
  9 #2. 函数的返回类型如 int 与 与函数名称要写到一行,否则会有问题,因为不太好判断函数名称.
 10 #3. 如果已经存在要生成的文件,会只写入你在.h中新加入的函数,
 11 #   但是注意原来已经存在的实现文件也应该是用h2cc.py生成的,因为我不是按语意判断,只是按照格式判断
 12 #   新写的实现函数框架,会附加到原来的生成文件最后面,需要自己调整到需要的位置,尤其是有namespace的时候
 13 #   TODO  新写的函数直接放到原来生成文件中适当的位置
 14 #4. 在生成的实现文件中,可能会把返回值单独一行,取决于行的长度,过长则分行
 15 #5. 如果template模板写成多行,确保最后一行只有一个单独的>
 16 #   template <
 17 #     typename T = char,
 18 #     template<typename> class _Decoder = HuffDecoder<int> #pattern like this might cause error 
 19 #   >
 20 
 21 
 22 #在某行发现) ; 之后,删除该行;之后的内容,该行开始的空白去掉
 23 #改为 \n\{\n\}
 24 # virtual = 0 对于纯虚函数也生成实体,如不需要自己去掉.  TODO 用户选项
 25 #TODO 允许向SGI STL源代码那样,将返回值单独一行,在函数名称上面,不过似乎比较困难,因为当前
 26 #我的程序基本按照(){}；template class typdef define // /* */识别这些字符的,仅仅考虑格式
 27 #不考虑语意如果返回值
 28 #单独一行,如何判断什么样的是返回值类型呢?比较麻烦.比如还要区分仅仅挨着占两行的两个函数声明.
 29 
 30 #最常用的pattern
 31 #查找如下 )  ;   或者 ) const ;  但是不包括纯虚函数
 32 #()z中如找到     ;  //从队尾删除
 33 #开始的空白要找到并删除，
 34 #pattern = re.compile(r"([\s]*?).*[)](?!\s*=\s*0).*(;.*)\n$")
 35 
 36 #class A : public 读出A未解决  done
 37 #template                      done 支持模板类,模板函数,带有默认参数的模板,模板类中的模板函数,特化和偏特化
 38 #                                   TODO  更复杂的情况可能有问题,比如模板类中嵌套模板类
 39 #vitrual = 0                   done
 40 #支持 const                    done
 41 #宏   DFDFDFEE（ABC);          done
 42 #把注释拷贝                    done
 43 #已经有.cpp了  仅仅加新的接口的实现 partly done  
 44 #忽略返回类型，返回类型不能重载
 45 #operator   done
 46 
 47 import sys,re,getopt
 48 
 49 def usage():
 50     """ 
 51         Run the program like this
 52         
 53         ./h2cc.py abc.h ok.cc
 54         It will read abc.h and append the fuctions 
 55         to be implemented to ok.cc
 56         
 57         or 
 58            ./h2cc.py abc.h         #will create abc.cc
 59            ./h2cc.py abc.h cpp     #will create abc.cpp
 60         """
 61 pattern_comment = re.compile(r'^\s*//')
 62 
 63 #传入一个打开的文件(我们要生成的或者已经存在要分析处理)的handle，如abc.cc
 64 #调用该函数者负责关闭该文件,该函数只负责处理
 65 func_list_exist = []
 66 def AnalyzeOutputFile(file_handle):
 67     print('Analyze output file right now ,the reslt of existing functions is below\n')
 68     file_handle.seek(0,0)
 69     m = file_handle.readlines()
 70     i = 0
 71     #---------------------------------------------------逐行处理
 72     while (i < len(m)):
 73         line = m[i]
 74         #---------------------判断是注释则略过  re.search(r'^s*$',line) 空行判断
 75         if re.search(r'^s*$',line) or pattern_comment.search(line): #null line or comment using //
 76             i += 1
 77             continue
 78         if re.search('^\s*/[*]', line):                             #comment using /*  
 79             while (not re.search('[*]/\s*$',line)):                 # */
 80                 i += 1
 81                 line = m[i]
 82             i += 1
 83             continue
 84         #-------------------------find exists functions
 85         find1 = re.search('[(]',line) 
 86         find2 = re.search('[)]',line)
 87         find3 = re.search('template',line)
 88         find4 = re.search('::',line)
 89         if ((find1 or find3 or find4) and (not find2)):
 90             i += 1
 91             line += m[i] 
 92             while (i < len(m) and (not re.search('[)]',line))):
 93                 i += 1
 94                 line += m[i]
 95         match = re.search('^.*\)',line,re.MULTILINE|re.DOTALL)
 96         if match:
 97             print(match.group())
 98             func_list_exist.append(match.group())
 99         i += 1
100     print('Output file analze done!')
101     print('There are already %d functions exit\n'%len(func_list_exist))
102 
103 #转化核心函数,当前比较乱,代码重复,一个循环中代码太长了 TODO 
104 #基本实现就是按照栈处理名称,区分是否class域的函数,忽略.h中已经实现函数{}内部的内容
105 def h2cc(input_file,output_file):
106     """
107         kernal function given a .h file
108         convert to a .cc one with
109         all the functions properly listed
110         """
111     print('The file you want to deal with is '+input_file + \
112         '\n It is converted to ' + output_file)
113   
114     #----核心的函数匹配模式
115     pattern = re.compile(r"""(^[\s]*)             #leading withe space,we will find and delete after
116                              ([a-zA-Z~_]            # void int likely the first caracter v or i
117                             .* 
118                             [)]                   #we find )
119                             #(?!\s*=\s*0)          #if we find = 0  which means pur virtual we will not match after
120                             #(?=\s*=\s*0) 
121                             (?!.*{)              # we do not want the case int abc() const { return 1;}
122                             .*)
123                             (;.*)                 #we want to find ; and after for we will replace these later
124                             \n$
125                             """,re.VERBOSE | re.MULTILINE | re.DOTALL)
126     
127     #----处理virtual,explicit,friend,static 
128     pattern2 = re.compile(r'(virtual\s+|explicit\s+|friend\s+|static\s+)')   
129     
130     #----开头的空白
131     leading_space_pattern = re.compile('(^[\s]*)[a-zA-Z~]')   
132     
133     #我们默认函数都会有 如 abc(  abc ( 这样的模式存在
134     #但是operator 是个例外,类名要加在operaotr前面，而且不存在上面的模式
135     #operator = ()     ClassName::operator = ()
136     #pattern_func_name = re.compile(r'([a-zA-Z0-9~_\-]+\s*[(]|operator.*[(])')   
137     #难道替换不是仅仅替换括号里面的 而是全部替换? 恩，大括号 必须的 然后用\1没有\0 
138     pattern_func_name = re.compile(r'([a-zA-Z0-9~_\-]+\s*|operator.*)[(]') 
139 
140     pattern_template = re.compile('^\s*template')
141     #pattern_template_end = re.compile('^\s*>\s*$') #TODO why wrong?
142     pattern_template_end = re.compile('>\s*$')
143 
144     pattern_namespace = re.compile(r'namespace.*{')       #判断该行是否是 namespace出现
145     #p2 = re.compile(r'class\s*(.*?)\s*{|struct\s*(.*?)\s*{')  
146     #.*? 最小匹配  是否class出现,并记录class 名称
147     pattern_class = re.compile(r'^[\s]*(class|struct)\s+([a-zA-Z0-9_\-]+<?)(?!.*;)') 
148     #modify 09.6.6 可以处理classa a 和 { 不在同一行，但是如果class 后发现;不处理
149     #class一定是行开始或者前面可有空白
150 
151     pattern_start = re.compile('{')
152     pattern_end = re.compile('}')
153     
154     stack = []                      #----状态可能是normal_now(位于{}中间的时候),class_now,namespace_now
155     stack_class = []                #----存储class name
156     stack_template = []             #----存储template name
157     stack_typedef = []              #----存储当前class 作用域下的所有typedef得到的名称,函数返回类型需要
158     
159     first_convert = True            #是否是第一次生成的实现文件
160     
161     #--------------------------------------文件处理
162     try:                              #09.6.6 处理要转换生成的.cc 或 .cpp文件不存在的情况，添加读异常
163         f_out = open(output_file,'r+')    #r+  可读写但要求文件已经存在
164         print(output_file + ' exists already, we will anlyze it to find the existing functions to avoid adding twice')
165         AnalyzeOutputFile(f_out)                         #对输出文件进行预处理分析
166         first_convert = False
167     except IOError:
168         print(output_file + ' does not exist yet, we will create am empty ' + output_file)
169         f_out = open(output_file,'a')     #追加打开，这里因为用了异常先判断了是否文件存在，所以也可以用 w
170                                           #如果没有前面的判断只能用 a ,w 会自动删除前面已有的内容
171     print('Below functions will be added\n')
172     if first_convert:
173         f_out.write('#include "' + input_file + '"\n\n')  #注意 如果out文件已存在 那么经过前面的分析处理 指针已经指向了文件尾部
174      
175     func_sum = 0
176     #--------------------------------------------------核心处理循环,逐行处理输入.h文件
177     with open(input_file,'r') as f:
178         m = f.readlines()
179         i = 0
180         while i < len(m):
181             line = m[i]
182             #-------------------------------------------判断是注释则略过  re.search(r'^s*$',line) 空行判断
183             if re.search(r'^s*$',line) or pattern_comment.search(line): #/n or comment using //
184                 i += 1
185                 continue
186             if re.search('^\s*/[*]', line):              #comment using /*  
187                 while (not re.search('[*]/\s*$',line)):  # */
188                     i += 1
189                     line = m[i]
190                 i += 1
191                 continue
192             #---------------------------------------------判断是则define略过
193             define_match = re.search(r'^\s*#define',line)
194             if define_match:
195                 while re.search(r'^\s*$',line) or re.search(r'\\\s*$', line):
196                     i += 1
197                     line = m[i]
198                 i += 1
199                 continue
200             #-----------------------------------------------判断是否namespace
201             match_namespace = pattern_namespace.search(line)
202             if match_namespace:                                   #we face namespace
203                 if first_convert:
204                   f_out.write(line+'\n')
205                 stack.append('namespace_now')
206                 i += 1
207                 continue
208             #----------------------------------------------------判断并处理类里面的typedef
209             if (len(stack) > 0 and stack[-1] == 'class_now'):
210                 pattern_typedef = re.compile(r'typedef\s+.*\s+(.*);')
211                 match_typedef =  pattern_typedef.search(line)
212                 if match_typedef:
213                     stack_typedef.append(match_typedef.group(1))
214             #----------------------------------------------------判断并处理模板情况  
215             match_template = pattern_template.search(line)
216             template_string = ''
217             if match_template:
218                 match_template_end = pattern_template_end.search(line)
219                 template_string = line
220                 while(not match_template_end):
221                     i += 1
222                     line = m[i]
223                     template_string += line
224                     match_template_end = pattern_template_end.search(line)
225                 i += 1
226                 line = m[i]
227             #--------------------------------------------判断是否是class 或者遇到 { start
228             match_class = pattern_class.search(line)  
229             match_start = pattern_start.search(line)
230 
231             if match_class:                  #we face a class
232                 stack_template.append(template_string)
233                 stack.append('class_now')
234                 class_name = match_class.group(2)   #TODO f2.group(1)如果为空则异常
235                 #-----------模板类特化或者偏特化的情况 如 class A<u,Node<u> > 为了获得整个名称
236                 if '<' in class_name:               
237                     k = line.index('<')
238                     fit = 1;
239                     for l in range(k+1, len(line)):
240                         if line[l] == '<':
241                             fit += 1
242                         if line[l] == '>':
243                             fit -= 1
244                         if (fit == 0):
245                             break
246                     class_name += line[k+1:l+1]
247                 stack_class.append(class_name)
248                 while not match_start:
249                     i += 1
250                     line = m[i]
251                     match_start = pattern_start.search(line)
252                 i += 1
253                 continue
254             #-------------------------------------------------判断是否是结束符号 }
255             match_end = pattern_end.search(line)
256             if match_start:
257                 stack.append('normal_now')
258             if match_end:
259                 top_status = stack.pop()
260                 if top_status == 'namespace_now':
261                     if first_convert:
262                       f_out.write(line+'\n')
263                 elif top_status == 'class_now':
264                     stack_class.pop()
265                     stack_template.pop()
266                     stack_typedef = []
267             if match_start or match_end:
268                 i += 1
269                 continue
270             #注意我判断是函数只是根据 我看到该行有) 然后 后面有;  important!!
271             #------------------------------------------------就像忽略注释一样忽略normal_now状态下的行,因为那是在{}中间的实现
272             if len(stack) >0 and stack[-1] == 'normal_now': 
273                 i += 1
274                 continue
275             #---------------------------------------------------------下面我们该处理需要生成实体框架的函数了,
276             #deal with
277             #int abc(int a,
278             #          int b)    #能够处理这种(与)不在同一行的情况
279             find1 = re.search('[(]',line)
280             if not find1:
281                 i += 1
282                 continue
283             find2 = re.search('[)]',line)
284             start_i = i
285             if (find1 and (not find2)):
286                 #space = leading_space_pattern.search(line).group(1)
287                 space_match = leading_space_pattern.search(line)
288                 i += 1
289                 line2 = m[i]
290                 if space_match:
291                     line2 = re.sub('^'+space_match.group(1),'',line2)     
292                     #注意sub会替换所有的匹配，这里我们只让它替换第一个,count=1，或者对于space 前面加^
293                 line += line2
294                 while (i < len(m) and (not re.search('[)]',line2))):
295                     i += 1
296                     line2 = m[i]
297                     line2 = re.sub('^'+space_match.group(1),'',line2)
298                     line += line2
299 
300             match_start = pattern_start.search(m[i])
301             match_end = pattern_end.search(m[i])
302             if (match_start):     # like  ) {  or ) {}    int the last line
303               if not match_end:
304                 stack.append('normal_now')
305               i += 1
306               continue
307  
308             #here we do the kernel sub  #--------------------------------如果找到,先进行了替换abc();->abc{}
309             (line,match) = pattern.subn(r'\2 \n{\n\n}\n\n',line)       
310             if (not match):   # like  abc()  not ; after 就是说{在函数名下面单独一行的情况
311                 i += 1
312                 continue
313 
314             #-------------------------------------------------------------OK,找到了函数,下面进行处理后输出
315             if match:                           
316                 friend_match = re.search('friend ',line)
317                 line = pattern2.sub('',line)            #--------------------delete virtural explict friend!
318                 func_name = ''
319                 template_line = ''
320                 if len(stack_class) > 0 and not friend_match :  #-----类成员函数class status if friend we will not add class name
321                     x = ''
322                     if (template_string != ''):                 #-----类中模板函数,多一个模板
323                         template_string = re.sub(r'\s*template','template',template_string)
324                         #template_string = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_string)
325                         #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
326                         template_string = re.sub('\s*=.*>(\s*)$',r'>\1',template_string)  
327                         template_string = re.sub(r'\s*=.*,',',',template_string)
328                         template_string = re.sub(r'\s*=.*','',template_string)
329                     if (stack_template[-1] != ''):
330                         if not (re.search(r'<\s*>', stack_template[-1])): #----不是全特化!template<>
331                             template_line = re.sub(r'^\s*template','template',stack_template[-1])
332                             if not (re.search(r'<.*>', stack_class[-1])): #----不是偏特化!,like template<typename T> class A<T,int>
333                                 #------for x we get like template<class T, typename U> -> <T,U>
334                                 x = re.sub(r'template\s*<','<',template_line)    #remove template -> <class T, typename U>
335                                 x = re.sub(r'\n','',x)                           #取消分行,合并成一行
336                                 #去掉 = 及其后面的东西
337                                 x = re.sub(r'\s*=.*,', ',', x)
338                                 x = re.sub(r'\s*=.*\>', '>', x)
339                                 x = x.rstrip()             #remove \n
340                                 x = re.sub(r'(class|typename)\s+|(<class>|<typename>\s*class)','',x) #去掉class,typename ->  <T, U>
341                                 x = re.sub(r'<\s+','<',x)
342                                 x = re.sub(r'\s+>','>',x)
343                                 x = re.sub(r'\s+,', ',',x)
344                                 x = re.sub(r',\s+', ', ',x)  
345                     line = re.sub(r'\s*=\s*0','',line)     #纯虚函数我们也给函数实现体，这里特别判断一下去掉 = 0
346                     line = re.sub(r'\s*=.*,',',', line)  #去掉=后面的东西 foo(int a = cd(32));foo(int x =(3), int y= 4);
347                     line = re.sub(r'\s*=.*\)',')', line)   #先去掉所有的(),最后去掉()),这两个步骤都需要不能颠倒
348                     #---------如果函数较长,在void ABC::foo()  断开成两行 void ABC::\n foo()
349                     temp_line = pattern_func_name.sub(stack_class[-1] + x + '::' + r'\1(',line)
350                     if len(temp_line) > 60:
351                         line = pattern_func_name.sub(stack_class[-1] + x + '::\n' + r'\1(',line)
352                     else:
353                         line = temp_line
354                     #----------得到返回变量的类型 
355                     return_type = re.search('^(\S+)', line).group(1)
356                     if (return_type in stack_typedef):  #------对于返回值,需要指明是在该类中typedef指定的名称的情况
357                         if (x == ''): #----全特化的情况特殊处理 
358                             line = re.sub('^'+return_type+r'\s+', stack_class[-1]+'::'+return_type+'\\n', line)
359                         else:
360                             line = re.sub('^'+return_type+r'\s+', 'typename '+stack_class[-1]+'::'+return_type+'\\n', line)
361                     #----------add template as the above if there is one
362                     #template_line = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_line)
363                     #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
364                     template_line = re.sub('\s*=.*>(\s*)$',r'>\1',template_line)
365                     template_line = re.sub(r'\s*=.*,',',',template_line)
366                     template_line = re.sub(r'\s*=.*','',template_line) #最后,不换行删除后面所有的
367                     line = template_line + template_string +  line;        
368                     func_name = re.search('^.*\)',line,re.MULTILINE|re.DOTALL).group()
369                 else:                  #--------------------------------普通函数(非类成员函数)的情况!
370                     stack_template.append(template_string)
371                     if  (stack_template[-1] != ''):
372                         template_line = re.sub(r'\s*template','template',stack_template[-1])
373                         #template_line = re.sub(r'\s*=\s*[\'a-zA-Z0-9_\-\.]+', '', template_line)
374                         #------------------delete < class T = a, class U = A(3)> -> <class T, class U>
375                         template_line = re.sub('\s*=.*>(\s*)$',r'>\1',template_line) #代码重复,TODO以后整合 
376                         template_line = re.sub(r'\s*=.*,',',',template_line)
377                         template_line = re.sub(r'\s*=.*','',template_line)
378                     line = re.sub(r'\s*=.*,', ',', line)
379                     line = re.sub(r'\s*=.*\)', ')', line)
380                     line = template_line + line
381                     stack_template.pop()
382                     func_name = re.search('^.*\)',line,re.MULTILINE|re.DOTALL).group()
383                 #-------------------------------------------------------------------------加上上面的注释也拷贝过去
384                 comment_line = ''                          
385                 #假定函数的注释在函数声明的紧上面，把他们拷贝过去
386                 #TODO 如果是模板函数,模板占多于1行注释没拷贝
387                 k = start_i - 1    #one line befor this func start
388                 if pattern_template.search(m[k]):
389                     k -= 1
390                 if re.search('[*]/\s*$',m[k]):
391                     comment_line = m[k].lstrip()
392                     while not re.search('^\s*/[*]',m[k]):
393                         k -= 1
394                         comment_line = m[k].lstrip() + comment_line 
395                 else:    
396                   for j in range(k,0,-1):
397                       c_line = m[j]
398                       if pattern_comment.search(c_line):
399                           c_line = re.sub('\s*//','//',c_line)  #TODO use strtip is ok?
400                           comment_line = c_line + comment_line
401                       else:
402                           break
403                 line = comment_line + line  #------------------我们最终要输出的东东
404                 #----------------------------------------------如果函数已经在实现文件中存在,不输出
405                 if not(func_name in func_list_exist):
406                     #if not first_convert and func_sum == 0:
407                     #    f_out.write("//newly added functions, you may need to move them to the right position\n")
408                     f_out.write(line)
409                     func_sum += 1
410                     print(func_name)
411             i += 1  #-----------------------------------------------------------------------next line处理下一行
412     #------------------------------loop done 处理结束 
413     print('\nSucessfully converted,please see '+output_file)
414     print('Added %d functions'%func_sum)
415 
416 
417 #-----------------------------------------------------------user input
418 def main(argv):                         
419     try:                                
420         opts, args = getopt.getopt(argv, "h", ["help"]) 
421     except getopt.GetoptError:           
422         print(usage.__doc__) 
423         sys.exit(2)
424 
425     if len(opts) > 0:
426         for o, a in opts: 
427             if o in ("-h", "--help"): 
428                 print(usage.__doc__) 
429                 sys.exit()
430     elif len(args) > 0:
431         input_file = args[0]
432         if len(args) == 1 or args[1] == 'cc':
433             output_file = re.sub('.h*$','.cc',input_file)  # 默认转的是对应的.cc文件
434         elif (args[1] == 'cpp'):
435             output_file = re.sub('.h*$','.cpp',input_file)
436         else:
437             output_file = args[1]
438             
439         h2cc(input_file,output_file)
440     else:
441         print(usage.__doc__)
442         sys.exit()
443 
444 
445 if __name__ == "__main__":
446     main(sys.argv[1:])
447 

下面看一下常用的几种函数声明，其对应函数实现的写法，包括模版类函数，模版类中的模版函数等等。

   1 /*演示函数定义的格式，主要演示在模版类外面定义成员函数的写法*/

  2 #include <iostream>
  3 using namespace std;
  4 
  5 int abc(int x = 3, int y = 4);
  6 
  7 template<typename T>
  8 struct HuffDecoder {
  9 
 10 };
 11 template <
 12   typename T = char,
 13   template<typename> class _Decoder = HuffDecoder
 14   >
 15 struct Hand{
 16   bool operator > (const Hand<T,_Decoder>& other);
 17   static void print();
 18 };
 19 
 20 template<typename T, template<typename> class _Decoder>
 21 void Hand<T, _Decoder>::print() 
 22 {
 23   cout << "this is hand" << endl;
 24 }
 25 
 26 template<typename T = char>
 27 class Foo {
 28   public:
 29     typedef T Node;
 30     typedef Hand<T> Handle;
 31     typedef int size;
 32 
 33     Handle foo(Node a);
 34 
 35     //Handle foo(Node a) {
 36     //  cout << "haha" << endl;
 37     //}
 38 
 39     //static Handle foo2(Node a = 'a') {
 40     //  cout << "haha" << endl;
 41     //}
 42     static Handle foo2(Node a = 'a');
 43 
 44     Hand<T> foo3();
 45 
 46     template <typename U>
 47     void swap(U x);
 48 
 49     //template <typename U>
 50     //class abc {
 51     //  public:
 52     //    static swap() 
 53     //};
 54 };
 55 
 56 template<typename T = char>
 57 class Derive : public Foo<T> 
 58 {
 59   public:
 60   typedef typename Foo<T>::size size; 
 61   static void print() {
 62     size l = 3333;
 63     cout << l << endl;
 64   }
 65 };
 66 template<>
 67 class Foo<int>
 68 {
 69   public:
 70     typedef int Node;
 71     typedef Hand<int> Handle;
 72     Handle foo(Node a);
 73     //Handle foo(Node a) {
 74     //  cout << "int foo" << endl;
 75     //}
 76     
 77 };
 78 
 79 template <typename T>
 80 class Foo<T*>
 81 {
 82   public:
 83     typedef Hand<int> Handle;
 84     typedef int Node;
 85     Handle foo(Node a);
 86 };
 87 
 88 template <typename T>
 89 typename Foo<T*>::Handle Foo<T*>::foo(Node a) {
 90   cout << "T * foo" << endl;
 91 }
 92 
 93 //template<>
 94 //typename Foo<int>::Handle Foo<int>::foo(Node a) 
 95 //{
 96 //  cout << "int foo" << endl;
 97 //}
 98 //
 99 Foo<int>::Handle Foo<int>::foo(Node a) 
100 {
101   cout << "int foo" << endl;
102 }
103 
104 //Hand<int> Foo<int>::foo(Node a) 
105 //{
106 //  cout << "int foo" << endl;
107 //}
108 //
109 template <typename T>
110 void print(T x);
111 
112 template <typename T>
113 void print(T x) 
114 {
115   cout << x << endl;
116 }
117 
118 template<typename T>
119 template<typename U>
120 void Foo<T>::swap(U x) 
121 {
122   cout << "hehe" << endl;
123 }
124 
125 template<typename T>
126 typename Foo<T>::Handle Foo<T>::foo(Node a) 
127 //Handle Foo<T>::foo(Node a)
128 {
129   size x = 23;
130   cout << x << endl;
131   cout << "haha" << endl;
132 }
133 
134 template<typename T>
135 typename Foo<T>::Handle Foo<T>::foo2(Node a) 
136 {
137   cout << "haha" << endl;
138 }
139 
140 template<typename T>
141 Hand<T> Foo<T>::foo3() 
142 {
143   cout << "haha" << endl;
144 }
145 
146 
147 int main(int argc, char *argv[])
148 {
149 
150   Derive<>::print();
151 
152   Hand<int> hand;
153   hand.print();
154 
155   Foo<>::foo2();
156   Foo<> foo;
157   foo.foo('a');
158 
159   foo.foo3();
160   
161   foo.swap(3);
162   
163   ::print(10);
164 
165   Foo<int> fooint;
166   fooint.foo(4);
167 
168   Foo<int *> foopint;
169   foopint.foo(4);
170   
171   return 0;
172 }
173 

 //用h2cc.py脚本生成的实现文件框架

  1 #include "test.h"

 2 
 3 int abc(int x, int y) 
 4 {
 5 
 6 }
 7 
 8 template <
 9   typename T,
10   template<typename> class _Decoder
11   >
12 bool Hand<T, _Decoder>::
13 operator > (const Hand<T,_Decoder>& other) 
14 {
15 
16 }
17 
18 template <
19   typename T,
20   template<typename> class _Decoder
21   >
22 void Hand<T, _Decoder>::print() 
23 {
24 
25 }
26 
27 template<typename T>
28 typename Foo::Handle
29 Foo<T>::foo(Node a) 
30 {
31 
32 }
33 
34 //static Handle foo2(Node a = 'a') {
35 //  cout << "haha" << endl;
36 //}
37 template<typename T>
38 typename Foo::Handle
39 Foo<T>::foo2(Node a) 
40 {
41 
42 }
43 
44 template<typename T>
45 Hand<T> Foo<T>::foo3() 
46 {
47 
48 }
49 
50 template<typename T>
51 template <typename U>
52 void Foo<T>::swap(U x) 
53 {
54 
55 }
56 
57 Foo<int>::Handle
58 Foo<int>::foo(Node a) 
59 {
60 
61 }
62 
63 template <typename T>
64 Foo<T*>::Handle
65 Foo<T*>::foo(Node a) 
66 {
67 
68 }
69 
70 //Hand<int> Foo<int>::foo(Node a) 
71 //{
72 //  cout << "int foo" << endl;
73 //}
74 //
75 template <typename T>
76 void print(T x) 
77 {
78 
79 }
80 

 // openmesh 中的一个头文件PolyMeshT.hh生成实现文件框架的示例

//PolyMeshT.hh

  1 /*===========================================================================*\
  2  *                                                                           *
  3  *                               OpenMesh                                    *
  4  *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
  5 //=============================================================================
  6 //
  7 //  CLASS PolyMeshT
  8 //
  9 //=============================================================================
 10 
 11 
 12 #ifndef OPENMESH_POLYMESHT_HH
 13 #define OPENMESH_POLYMESHT_HH
 14 
 15 
 16 //== INCLUDES =================================================================
 17 
 18 
 19 #include <OpenMesh/Core/System/config.h>
 20 #include <OpenMesh/Core/Geometry/MathDefs.hh>
 21 #include <OpenMesh/Core/Mesh/PolyConnectivity.hh>
 22 #include <vector>
 23 
 24 
 25 //== NAMESPACES ===============================================================
 26 
 27 
 28 namespace OpenMesh {
 29 
 30 
 31 //== CLASS DEFINITION =========================================================
 32 
 33 
 34 /** \class PolyMeshT PolyMeshT.hh <OpenMesh/Mesh/PolyMeshT.hh>
 35 
 36     Base type for a polygonal mesh.
 37 
 38     This is the base class for a polygonal mesh. It is parameterized
 39     by a mesh kernel that is given as a template argument. This class
 40     inherits all methods from its mesh kernel.
 41 
 42     \param Kernel: template argument for the mesh kernel
 43     \note You should use the predefined mesh-kernel combinations in
 44     \ref mesh_types_group
 45     \see \ref mesh_type
 46 */
 47 
 48 template <class Kernel>
 49 class PolyMeshT : public Kernel
 50 {
 51 public:
 52 
 53   /// Self type. Used to specify iterators/circulators.
 54   typedef PolyMeshT<Kernel>                   This;
 55   //--- item types ---
 56 
 57   //@{
 58   /// Determine whether this is a PolyMeshT or TriMeshT ( This function does not check the per face vertex count! It only checks if the datatype is PolyMeshT or TriMeshT )
 59   enum { IsPolyMesh = 1 };
 60   enum { IsTriMesh  = 0 };
 61   static bool is_polymesh() { return true;  }
 62   static bool is_trimesh()  { return false; }
 63   //@}
 64 
 65   /// \name Mesh Items
 66   //@{
 67   /// Scalar type
 68   typedef typename Kernel::Scalar    Scalar;
 69   /// Coordinate type
 70   typedef typename Kernel::Point     Point;
 71   /// Normal type
 72   typedef typename Kernel::Normal    Normal;
 73   /// Color type
 74   typedef typename Kernel::Color     Color;
 75   /// TexCoord1D type
 76   typedef typename Kernel::TexCoord1D  TexCoord1D;
 77   /// TexCoord2D type
 78   typedef typename Kernel::TexCoord2D  TexCoord2D;
 79   /// TexCoord3D type
 80   typedef typename Kernel::TexCoord3D  TexCoord3D;
 81   /// Vertex type
 82   typedef typename Kernel::Vertex    Vertex;
 83   /// Halfedge type
 84   typedef typename Kernel::Halfedge  Halfedge;
 85   /// Edge type
 86   typedef typename Kernel::Edge      Edge;
 87   /// Face type
 88   typedef typename Kernel::Face      Face;
 89   //@}
 90 
 91   //--- handle types ---
 92 
 93   /// Handle for referencing the corresponding item
 94   typedef typename Kernel::VertexHandle       VertexHandle;
 95   typedef typename Kernel::HalfedgeHandle     HalfedgeHandle;
 96   typedef typename Kernel::EdgeHandle         EdgeHandle;
 97   typedef typename Kernel::FaceHandle         FaceHandle;
 98 
 99 
100 
101   typedef typename Kernel::VertexIter                 VertexIter;
102   typedef typename Kernel::HalfedgeIter               HalfedgeIter;
103   typedef typename Kernel::EdgeIter                   EdgeIter;
104   typedef typename Kernel::FaceIter                   FaceIter;
105 
106   typedef typename Kernel::ConstVertexIter            ConstVertexIter;
107   typedef typename Kernel::ConstHalfedgeIter          ConstHalfedgeIter;
108   typedef typename Kernel::ConstEdgeIter              ConstEdgeIter;
109   typedef typename Kernel::ConstFaceIter              ConstFaceIter;
110   //@}
111 
112   //--- circulators ---
113 
114   /** \name Mesh Circulators
115       Refer to OpenMesh::Mesh::Iterators or \ref mesh_iterators
116       for documentation.
117   */
118   //@{
119   /// Circulator
120   typedef typename Kernel::VertexVertexIter          VertexVertexIter;
121   typedef typename Kernel::VertexOHalfedgeIter       VertexOHalfedgeIter;
122   typedef typename Kernel::VertexIHalfedgeIter       VertexIHalfedgeIter;
123   typedef typename Kernel::VertexEdgeIter            VertexEdgeIter;
124   typedef typename Kernel::VertexFaceIter            VertexFaceIter;
125   typedef typename Kernel::FaceVertexIter            FaceVertexIter;
126   typedef typename Kernel::FaceHalfedgeIter          FaceHalfedgeIter;
127   typedef typename Kernel::FaceEdgeIter              FaceEdgeIter;
128   typedef typename Kernel::FaceFaceIter              FaceFaceIter;
129 
130   typedef typename Kernel::ConstVertexVertexIter     ConstVertexVertexIter;
131   typedef typename Kernel::ConstVertexOHalfedgeIter  ConstVertexOHalfedgeIter;
132   typedef typename Kernel::ConstVertexIHalfedgeIter  ConstVertexIHalfedgeIter;
133   typedef typename Kernel::ConstVertexEdgeIter       ConstVertexEdgeIter;
134   typedef typename Kernel::ConstVertexFaceIter       ConstVertexFaceIter;
135   typedef typename Kernel::ConstFaceVertexIter       ConstFaceVertexIter;
136   typedef typename Kernel::ConstFaceHalfedgeIter     ConstFaceHalfedgeIter;
137   typedef typename Kernel::ConstFaceEdgeIter         ConstFaceEdgeIter;
138   typedef typename Kernel::ConstFaceFaceIter         ConstFaceFaceIter;
139   //@}
140 
141 
142   // --- constructor/destructor
143   PolyMeshT() {}
144   virtual ~PolyMeshT() {}
145 
146   /** Uses default copy and assignment operator.
147       Use them to assign two meshes of \b equal type.
148       If the mesh types vary, use PolyMeshT::assign() instead. */
149 
150    // --- creation ---
151   inline VertexHandle new_vertex()
152   { return Kernel::new_vertex(); }
153 
154   inline VertexHandle new_vertex(const Point& _p)
155   {
156     VertexHandle vh(Kernel::new_vertex());
157     set_point(vh, _p);
158     return vh;
159   }
160 
161   inline VertexHandle add_vertex(const Point& _p)
162   { return new_vertex(_p); }
163 
164   // --- normal vectors ---
165 
166   /** \name Normal vector computation
167   */
168   //@{
169 
170   /** Calls update_face_normals() and update_vertex_normals() if
171       these normals (i.e. the properties) exist */
172   void update_normals();
173 
174   /// Update normal for face _fh
175   void update_normal(FaceHandle _fh)
176   { set_normal(_fh, calc_face_normal(_fh)); }
177 
178   /** Update normal vectors for all faces.
179       \attention Needs the Attributes::Normal attribute for faces. */
180   void update_face_normals();
181 
182   /** Calculate normal vector for face _fh. */
183   Normal calc_face_normal(FaceHandle _fh) const;
184 
185   /** Calculate normal vector for face (_p0, _p1, _p2). */
186   Normal calc_face_normal(const Point& _p0, const Point& _p1,
187                                             const Point& _p2) const;
188   // calculates the average of the vertices defining _fh
189   void calc_face_centroid(FaceHandle _fh, Point& _pt) const;
190   /// Update normal for vertex _vh
191   void update_normal(VertexHandle _vh)
192   { set_normal(_vh, calc_vertex_normal(_vh)); }
193 
194   /** Update normal vectors for all vertices. \attention Needs the
195       Attributes::Normal attribute for faces and vertices. */
196   void update_vertex_normals();
197 
198   /** Calculate normal vector for vertex _vh by averaging normals
199       of adjacent faces. Face normals have to be computed first.
200       \attention Needs the Attributes::Normal attribute for faces. */
201   Normal calc_vertex_normal(VertexHandle _vh) const;
202 
203   /** Different methods for calculation of the normal at _vh:
204       - -"-_fast    - the default one - the same as calc vertex_normal()
205                     - needs the Attributes::Normal attribute for faces
206       - -"-_correct - works properly for non-triangular meshes
207                     - does not need any attributes
208       - -"-_loop    - calculates loop surface normals
209                     - does not need any attributes */
210   void calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const;
211   void calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const;
212   void calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const;
213 
214 
215   //@}
216 
217   // --- Geometry API - still in development ---
218 
219   /** Calculates the edge vector as the vector defined by
220       the halfedge with id #0 (see below)  */
221   void calc_edge_vector(EdgeHandle _eh, Normal& _edge_vec) const
222   { calc_edge_vector(halfedge_handle(_eh,0), _edge_vec); }
223 
224   /** Calculates the edge vector as the difference of the
225       the points defined by to_vertex_handle() and from_vertex_handle() */
226   void calc_edge_vector(HalfedgeHandle _heh, Normal& _edge_vec) const
227   {
228     _edge_vec = point(to_vertex_handle(_heh));
229     _edge_vec -= point(from_vertex_handle(_heh));
230   }
231 
232   // Calculates the length of the edge _eh
233   Scalar calc_edge_length(EdgeHandle _eh) const
234   { return calc_edge_length(halfedge_handle(_eh,0)); }
235 
236   /** Calculates the length of the edge _heh
237   */
238   Scalar calc_edge_length(HalfedgeHandle _heh) const
239   { return (Scalar)sqrt(calc_edge_sqr_length(_heh)); }
240 
241   Scalar calc_edge_sqr_length(EdgeHandle _eh) const
242   { return calc_edge_sqr_length(halfedge_handle(_eh,0)); }
243 
244   Scalar calc_edge_sqr_length(HalfedgeHandle _heh) const
245   {
246     Normal edge_vec;
247     calc_edge_vector(_heh, edge_vec);
248     return edge_vec.sqrnorm();
249   }
250 
251   /** defines a consistent representation of a sector geometry:
252       the halfedge _in_heh defines the sector orientation
253       the vertex pointed by _in_heh defines the sector center
254       _vec0 and _vec1 are resp. the first and the second vectors defining the sector */
255   void calc_sector_vectors(HalfedgeHandle _in_heh, Normal& _vec0, Normal& _vec1) const
256   {
257     calc_edge_vector(next_halfedge_handle(_in_heh), _vec0);//p2 - p1
258     calc_edge_vector(opposite_halfedge_handle(_in_heh), _vec1);//p0 - p1
259   }
260 
261   /** calculates the sector angle.\n
262    * The vertex pointed by _in_heh defines the sector center
263    * The angle will be calculated between the given halfedge and the next halfedge.\n
264    * Seen from the center vertex this will be the next halfedge in clockwise direction.\n
265       NOTE: only boundary concave sectors are treated correctly */
266   Scalar calc_sector_angle(HalfedgeHandle _in_heh) const
267   {
268     Normal v0, v1;
269     calc_sector_vectors(_in_heh, v0, v1);
270     Scalar denom = v0.norm()*v1.norm();
271     if (is_zero(denom))
272     {
273       return 0;
274     }
275     Scalar cos_a = (v0 | v1) / denom;
276     if (is_boundary(_in_heh))
277     {//determine if the boundary sector is concave or convex
278       FaceHandle fh(face_handle(opposite_halfedge_handle(_in_heh)));
279       Normal f_n(calc_face_normal(fh));//this normal is (for convex fh) OK
280       Scalar sign_a = dot(cross(v0, v1), f_n);
281       return angle(cos_a, sign_a);
282     }
283     else
284     {
285       return acos(sane_aarg(cos_a));
286     }
287   }
288 
289   // calculate the cos and the sin of angle <(_in_heh,next_halfedge(_in_heh))
290   /*
291   void calc_sector_angle_cos_sin(HalfedgeHandle _in_heh, Scalar& _cos_a, Scalar& _sin_a) const
292   {
293     Normal in_vec, out_vec;
294     calc_edge_vector(_in_heh, in_vec);
295     calc_edge_vector(next_halfedge_handle(_in_heh), out_vec);
296     Scalar denom = in_vec.norm()*out_vec.norm();
297     if (is_zero(denom))
298     {
299       _cos_a = 1;
300       _sin_a = 0;
301     }
302     else
303     {
304       _cos_a = dot(in_vec, out_vec)/denom;
305       _sin_a = cross(in_vec, out_vec).norm()/denom;
306     }
307   }
308   */
309   /** calculates the normal (non-normalized) of the face sector defined by
310       the angle <(_in_heh,next_halfedge(_in_heh)) */
311   void calc_sector_normal(HalfedgeHandle _in_heh, Normal& _sector_normal) const
312   {
313     Normal vec0, vec1;
314     calc_sector_vectors(_in_heh, vec0, vec1);
315     _sector_normal = cross(vec0, vec1);//(p2-p1)^(p0-p1)
316   }
317 
318   /** calculates the area of the face sector defined by
319       the angle <(_in_heh,next_halfedge(_in_heh))
320       NOTE: special cases (e.g. concave sectors) are not handled correctly */
321   Scalar calc_sector_area(HalfedgeHandle _in_heh) const
322   {
323     Normal sector_normal;
324     calc_sector_normal(_in_heh, sector_normal);
325     return sector_normal.norm()/2;
326   }
327 
328   /** calculates the dihedral angle on the halfedge _heh
329       \attention Needs the Attributes::Normal attribute for faces */
330   Scalar calc_dihedral_angle_fast(HalfedgeHandle _heh) const
331   {
332     CHECK(Kernel::has_face_normals());
333     if (is_boundary(edge_handle(_heh)))
334     {//the dihedral angle at a boundary edge is 0
335       return 0;
336     }
337     const Normal& n0 = normal(face_handle(_heh));
338     const Normal& n1 = normal(face_handle(opposite_halfedge_handle(_heh)));
339     Normal he;
340     calc_edge_vector(_heh, he);
341     Scalar da_cos = dot(n0, n1);
342     //should be normalized, but we need only the sign
343     Scalar da_sin_sign = dot(cross(n0, n1), he);
344     return angle(da_cos, da_sin_sign);
345   }
346 
347   /** calculates the dihedral angle on the edge _eh
348       \attention Needs the Attributes::Normal attribute for faces */
349   Scalar calc_dihedral_angle_fast(EdgeHandle _eh) const
350   { return calc_dihedral_angle_fast(halfedge_handle(_eh,0)); }
351 
352   // calculates the dihedral angle on the halfedge _heh
353   Scalar calc_dihedral_angle(HalfedgeHandle _heh) const
354   {
355     if (is_boundary(edge_handle(_heh)))
356     {//the dihedral angle at a boundary edge is 0
357       return 0;
358     }
359     Normal n0, n1, he;
360     calc_sector_normal(_heh, n0);
361     calc_sector_normal(opposite_halfedge_handle(_heh), n1);
362     calc_edge_vector(_heh, he);
363     Scalar denom = n0.norm()*n1.norm();
364     if (denom == Scalar(0))
365     {
366       return 0;
367     }
368     Scalar da_cos = dot(n0, n1)/denom;
369     //should be normalized, but we need only the sign
370     Scalar da_sin_sign = dot(cross(n0, n1), he);
371     return angle(da_cos, da_sin_sign);
372   }
373 
374   // calculates the dihedral angle on the edge _eh
375   Scalar calc_dihedral_angle(EdgeHandle _eh) const
376   { return calc_dihedral_angle(halfedge_handle(_eh,0)); }
377 
378   /** tags an edge as a feature if its dihedral angle is larger than _angle_tresh
379       returns the number of the found feature edges, requires edge_status property*/
380   uint find_feature_edges(Scalar _angle_tresh = OpenMesh::deg_to_rad(44.0));
381   // --- misc ---
382 
383   /// Face split (= 1-to-n split)
384   inline void split(FaceHandle _fh, const Point& _p)
385   { Kernel::split(_fh, add_vertex(_p)); }
386 
387   inline void split(FaceHandle _fh, VertexHandle _vh)
388   { Kernel::split(_fh, _vh); }
389 
390   inline void split(EdgeHandle _eh, const Point& _p)
391   { Kernel::split(_eh, add_vertex(_p)); }
392 
393   inline void split(EdgeHandle _eh, VertexHandle _vh)
394   { Kernel::split(_eh, _vh); }
395 };
396 
397 
398 //=============================================================================
399 } // namespace OpenMesh
400 //=============================================================================
401 #if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_POLYMESH_C)
402 #  define OPENMESH_POLYMESH_TEMPLATES
403 #  include "PolyMeshT.cc"
404 #endif
405 //=============================================================================
406 #endif // OPENMESH_POLYMESHT_HH defined
407 //=============================================================================

408

//用h2cc.py生成的实现文件框架PolyMeshT.cpp

 //PolyMeshT.cpp  #h2cc.py自动生成

     1 #include "PolyMeshT.hh"

  2 
  3 namespace OpenMesh {
  4 
  5 /** Calls update_face_normals() and update_vertex_normals() if
  6 these normals (i.e. the properties) exist */
  7 template <class Kernel>
  8 void PolyMeshT<Kernel>::update_normals() 
  9 {
 10 
 11 }
 12 
 13 /** Update normal vectors for all faces.
 14 \attention Needs the Attributes::Normal attribute for faces. */
 15 template <class Kernel>
 16 void PolyMeshT<Kernel>::update_face_normals() 
 17 {
 18 
 19 }
 20 
 21 /** Calculate normal vector for face _fh. */
 22 template <class Kernel>
 23 typename PolyMeshT::Normal
 24 PolyMeshT<Kernel>::
 25 calc_face_normal(FaceHandle _fh) const 
 26 {
 27 
 28 }
 29 
 30 /** Calculate normal vector for face (_p0, _p1, _p2). */
 31 template <class Kernel>
 32 typename PolyMeshT::Normal
 33 PolyMeshT<Kernel>::
 34 calc_face_normal(const Point& _p0, const Point& _p1,
 35                                           const Point& _p2) const 
 36 {
 37 
 38 }
 39 
 40 // calculates the average of the vertices defining _fh
 41 template <class Kernel>
 42 void PolyMeshT<Kernel>::
 43 calc_face_centroid(FaceHandle _fh, Point& _pt) const 
 44 {
 45 
 46 }
 47 
 48 /** Update normal vectors for all vertices. \attention Needs the
 49 Attributes::Normal attribute for faces and vertices. */
 50 template <class Kernel>
 51 void PolyMeshT<Kernel>::update_vertex_normals() 
 52 {
 53 
 54 }
 55 
 56 /** Calculate normal vector for vertex _vh by averaging normals
 57 of adjacent faces. Face normals have to be computed first.
 58 \attention Needs the Attributes::Normal attribute for faces. */
 59 template <class Kernel>
 60 typename PolyMeshT::Normal
 61 PolyMeshT<Kernel>::
 62 calc_vertex_normal(VertexHandle _vh) const 
 63 {
 64 
 65 }
 66 
 67 /** Different methods for calculation of the normal at _vh:
 68 - -"-_fast    - the default one - the same as calc vertex_normal()
 69 - needs the Attributes::Normal attribute for faces
 70 - -"-_correct - works properly for non-triangular meshes
 71 - does not need any attributes
 72 - -"-_loop    - calculates loop surface normals
 73 - does not need any attributes */
 74 template <class Kernel>
 75 void PolyMeshT<Kernel>::
 76 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const 
 77 {
 78 
 79 }
 80 
 81 template <class Kernel>
 82 void PolyMeshT<Kernel>::
 83 calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const 
 84 {
 85 
 86 }
 87 
 88 template <class Kernel>
 89 void PolyMeshT<Kernel>::
 90 calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const 
 91 {
 92 
 93 }
 94 
 95 /** tags an edge as a feature if its dihedral angle is larger than _angle_tresh
 96 returns the number of the found feature edges, requires edge_status property*/
 97 template <class Kernel>
 98 uint PolyMeshT<Kernel>::
 99 find_feature_edges(Scalar _angle_tresh) 
100 {
101 
102 }
103 
104 } // namespace OpenMesh
105 

//Openmesh提供的对应PolyMeshT.hh的实现文件PolyMeshT.cc可以和上面自动生成的框架对比一下：） 

   1 //=============================================================================

  2 //
  3 //  CLASS PolyMeshT - IMPLEMENTATION
  4 //
  5 //=============================================================================
  6 
  7 
  8 #define OPENMESH_POLYMESH_C
  9 
 10 
 11 //== INCLUDES =================================================================
 12 
 13 #include <OpenMesh/Core/Mesh/PolyMeshT.hh>
 14 #include <OpenMesh/Core/Geometry/LoopSchemeMaskT.hh>
 15 #include <OpenMesh/Core/Utils/vector_cast.hh>
 16 #include <OpenMesh/Core/System/omstream.hh>
 17 #include <vector>
 18 
 19 
 20 //== NAMESPACES ===============================================================
 21 
 22 
 23 namespace OpenMesh {
 24 
 25 //== IMPLEMENTATION ==========================================================
 26 
 27 template <class Kernel>
 28 uint PolyMeshT<Kernel>::find_feature_edges(Scalar _angle_tresh)
 29 {
 30   assert(Kernel::has_edge_status());//this function needs edge status property
 31   uint n_feature_edges = 0;
 32   for (EdgeIter e_it = Kernel::edges_begin(); e_it != Kernel::edges_end(); ++e_it)
 33   {
 34     if (fabs(calc_dihedral_angle(e_it)) > _angle_tresh)
 35     {//note: could be optimized by comparing cos(dih_angle) vs. cos(_angle_tresh)
 36       status(e_it).set_feature(true);
 37       n_feature_edges++;
 38     }
 39     else
 40     {
 41       status(e_it).set_feature(false);
 42     }
 43   }
 44   return n_feature_edges;
 45 }
 46 
 47 //-----------------------------------------------------------------------------
 48 
 49 template <class Kernel>
 50 typename PolyMeshT<Kernel>::Normal
 51 PolyMeshT<Kernel>::
 52 calc_face_normal(FaceHandle _fh) const
 53 {
 54   assert(halfedge_handle(_fh).is_valid());
 55   ConstFaceVertexIter fv_it(cfv_iter(_fh));
 56 
 57   const Point& p0(point(fv_it));  ++fv_it;
 58   const Point& p1(point(fv_it));  ++fv_it;
 59   const Point& p2(point(fv_it));
 60 
 61   return calc_face_normal(p0, p1, p2);
 62 }
 63 
 64 
 65 //-----------------------------------------------------------------------------
 66 
 67 
 68 template <class Kernel>
 69 typename PolyMeshT<Kernel>::Normal
 70 PolyMeshT<Kernel>::
 71 calc_face_normal(const Point& _p0,
 72      const Point& _p1,
 73      const Point& _p2) const
 74 {
 75 #if 1
 76   // The OpenSG <Vector>::operator -= () does not support the type Point
 77   // as rhs. Therefore use vector_cast at this point!!!
 78   // Note! OpenSG distinguishes between Normal and Point!!!
 79   Normal p1p0(_p0);  p1p0 -= vector_cast<Normal>(_p1);
 80   Normal p1p2(_p2);  p1p2 -= vector_cast<Normal>(_p1);
 81 
 82   Normal n    = cross(p1p2, p1p0);
 83   Scalar norm = n.length();
 84 
 85   // The expression ((n *= (1.0/norm)),n) is used because the OpenSG
 86   // vector class does not return self after component-wise
 87   // self-multiplication with a scalar!!!
 88   return (norm != Scalar(0)) ? ((n *= (Scalar(1)/norm)),n) : Normal(0,0,0);
 89 #else
 90   Point p1p0 = _p0;  p1p0 -= _p1;
 91   Point p1p2 = _p2;  p1p2 -= _p1;
 92 
 93   Normal n = vector_cast<Normal>(cross(p1p2, p1p0));
 94   Scalar norm = n.length();
 95 
 96   return (norm != 0.0) ? n *= (1.0/norm) : Normal(0,0,0);
 97 #endif
 98 }
 99 
100 //-----------------------------------------------------------------------------
101 
102 template <class Kernel>
103 void
104 PolyMeshT<Kernel>::
105 calc_face_centroid(FaceHandle _fh, Point& _pt) const
106 {
107   _pt.vectorize(0);
108   uint valence = 0;
109   for (ConstFaceVertexIter cfv_it = cfv_iter(_fh); cfv_it; ++cfv_it, ++valence)
110   {
111     _pt += point(cfv_it);
112   }
113   _pt /= valence;
114 }
115 //-----------------------------------------------------------------------------
116 
117 
118 template <class Kernel>
119 void
120 PolyMeshT<Kernel>::
121 update_normals()
122 {
123   if (Kernel::has_face_normals())    update_face_normals();
124   if (Kernel::has_vertex_normals())  update_vertex_normals();
125 }
126 
127 
128 //-----------------------------------------------------------------------------
129 
130 
131 template <class Kernel>
132 void
133 PolyMeshT<Kernel>::
134 update_face_normals()
135 {
136   FaceIter f_it(Kernel::faces_begin()), f_end(Kernel::faces_end());
137 
138   for (; f_it != f_end; ++f_it)
139     set_normal(f_it.handle(), calc_face_normal(f_it.handle()));
140 }
141 
142 
143 //-----------------------------------------------------------------------------
144 
145 
146 template <class Kernel>
147 typename PolyMeshT<Kernel>::Normal
148 PolyMeshT<Kernel>::
149 calc_vertex_normal(VertexHandle _vh) const
150 {
151   Normal n;
152   calc_vertex_normal_fast(_vh,n);
153 
154   Scalar norm = n.length();
155   if (norm != 0.0) n *= (1.0/norm);
156 
157   return n;
158 }
159 
160 //-----------------------------------------------------------------------------
161 template <class Kernel>
162 void PolyMeshT<Kernel>::
163 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const
164 {
165   _n.vectorize(0.0);
166   for (ConstVertexFaceIter vf_it=cvf_iter(_vh); vf_it; ++vf_it)
167     _n += normal(vf_it.handle());
168 }
169 
170 //-----------------------------------------------------------------------------
171 template <class Kernel>
172 void PolyMeshT<Kernel>::
173 calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const
174 {
175   _n.vectorize(0.0);
176   ConstVertexIHalfedgeIter cvih_it = cvih_iter(_vh);
177   if (!cvih_it)
178   {//don't crash on isolated vertices
179     return;
180   }
181   Normal in_he_vec;
182   calc_edge_vector(cvih_it, in_he_vec);
183   for ( ; cvih_it; ++cvih_it)
184   {//calculates the sector normal defined by cvih_it and adds it to _n
185     if (is_boundary(cvih_it))
186     {
187       continue;
188     }
189     HalfedgeHandle out_heh(next_halfedge_handle(cvih_it));
190     Normal out_he_vec;
191     calc_edge_vector(out_heh, out_he_vec);
192     _n += cross(in_he_vec, out_he_vec);//sector area is taken into account
193     in_he_vec = out_he_vec;
194     in_he_vec *= -1;//change the orientation
195   }
196 }
197 
198 //-----------------------------------------------------------------------------
199 template <class Kernel>
200 void PolyMeshT<Kernel>::
201 calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const
202 {
203   static const LoopSchemeMaskDouble& loop_scheme_mask__ =
204                   LoopSchemeMaskDoubleSingleton::Instance();
205 
206   Normal t_v(0.0,0.0,0.0), t_w(0.0,0.0,0.0);
207   unsigned int vh_val = valence(_vh);
208   unsigned int i = 0;
209   for (ConstVertexOHalfedgeIter cvoh_it = cvoh_iter(_vh); cvoh_it; ++cvoh_it, ++i)
210   {
211     VertexHandle r1_v(to_vertex_handle(cvoh_it));
212     t_v += (typename Point::value_type)(loop_scheme_mask__.tang0_weight(vh_val, i))*point(r1_v);
213     t_w += (typename Point::value_type)(loop_scheme_mask__.tang1_weight(vh_val, i))*point(r1_v);
214   }
215   _n = cross(t_w, t_v);//hack: should be cross(t_v, t_w), but then the normals are reversed?
216 }
217 
218 //-----------------------------------------------------------------------------
219 
220 
221 template <class Kernel>
222 void
223 PolyMeshT<Kernel>::
224 update_vertex_normals()
225 {
226   VertexIter  v_it(Kernel::vertices_begin()), v_end(Kernel::vertices_end());
227 
228   for (; v_it!=v_end; ++v_it)
229     set_normal(v_it.handle(), calc_vertex_normal(v_it.handle()));
230 }
231 
232 //=============================================================================
233 } // namespace OpenMesh
234 //=============================================================================
235 

//看一个非模版类的示例，google test的一个头文件  gtest-filepath.h

  1 
  2 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
  3 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
  4 
  5 #include <gtest/internal/gtest-string.h>
  6 
  7 namespace testing {
  8 namespace internal {
  9 
 10 // FilePath - a class for file and directory pathname manipulation which
 11 // handles platform-specific conventions (like the pathname separator).
 12 // Used for helper functions for naming files in a directory for xml output.
 13 // Except for Set methods, all methods are const or static, which provides an
 14 // "immutable value object" -- useful for peace of mind.
 15 // A FilePath with a value ending in a path separator ("like/this/") represents
 16 // a directory, otherwise it is assumed to represent a file. In either case,
 17 // it may or may not represent an actual file or directory in the file system.
 18 // Names are NOT checked for syntax correctness -- no checking for illegal
 19 // characters, malformed paths, etc.
 20 
 21 class FilePath {
 22  public:
 23   FilePath() : pathname_("") { }
 24   FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
 25 
 26   explicit FilePath(const char* pathname) : pathname_(pathname) {
 27     Normalize();
 28   }
 29 
 30   explicit FilePath(const String& pathname) : pathname_(pathname) {
 31     Normalize();
 32   }
 33 
 34   FilePath& operator=(const FilePath& rhs) {
 35     Set(rhs);
 36     return *this;
 37   }
 38 
 39   void Set(const FilePath& rhs) {
 40     pathname_ = rhs.pathname_;
 41   }
 42 
 43   String ToString() const { return pathname_; }
 44   const char* c_str() const { return pathname_.c_str(); }
 45 
 46   // Returns the current working directory, or "" if unsuccessful.
 47   static FilePath GetCurrentDir();
 48 
 49   // Given directory = "dir", base_name = "test", number = 0,
 50   // extension = "xml", returns "dir/test.xml". If number is greater
 51   // than zero (e.g., 12), returns "dir/test_12.xml".
 52   // On Windows platform, uses \ as the separator rather than /.
 53   static FilePath MakeFileName(const FilePath& directory,
 54                                const FilePath& base_name,
 55                                int number,
 56                                const char* extension);
 57 
 58   // Given directory = "dir", relative_path = "test.xml",
 59   // returns "dir/test.xml".
 60   // On Windows, uses \ as the separator rather than /.
 61   static FilePath ConcatPaths(const FilePath& directory,
 62                               const FilePath& relative_path);
 63 
 64   // Returns a pathname for a file that does not currently exist. The pathname
 65   // will be directory/base_name.extension or
 66   // directory/base_name_<number>.extension if directory/base_name.extension
 67   // already exists. The number will be incremented until a pathname is found
 68   // that does not already exist.
 69   // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
 70   // There could be a race condition if two or more processes are calling this
 71   // function at the same time -- they could both pick the same filename.
 72   static FilePath GenerateUniqueFileName(const FilePath& directory,
 73                                          const FilePath& base_name,
 74                                          const char* extension);
 75 
 76   // Returns true iff the path is NULL or "".
 77   bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; }
 78 
 79   // If input name has a trailing separator character, removes it and returns
 80   // the name, otherwise return the name string unmodified.
 81   // On Windows platform, uses \ as the separator, other platforms use /.
 82   FilePath RemoveTrailingPathSeparator() const;
 83 
 84   // Returns a copy of the FilePath with the directory part removed.
 85   // Example: FilePath("path/to/file").RemoveDirectoryName() returns
 86   // FilePath("file"). If there is no directory part ("just_a_file"), it returns
 87   // the FilePath unmodified. If there is no file part ("just_a_dir/") it
 88   // returns an empty FilePath ("").
 89   // On Windows platform, '\' is the path separator, otherwise it is '/'.
 90   FilePath RemoveDirectoryName() const;
 91 
 92   // RemoveFileName returns the directory path with the filename removed.
 93   // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
 94   // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
 95   // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
 96   // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
 97   // On Windows platform, '\' is the path separator, otherwise it is '/'.
 98   FilePath RemoveFileName() const;
 99 
100   // Returns a copy of the FilePath with the case-insensitive extension removed.
101   // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
102   // FilePath("dir/file"). If a case-insensitive extension is not
103   // found, returns a copy of the original FilePath.
104   FilePath RemoveExtension(const char* extension) const;
105 
106   // Creates directories so that path exists. Returns true if successful or if
107   // the directories already exist; returns false if unable to create
108   // directories for any reason. Will also return false if the FilePath does
109   // not represent a directory (that is, it doesn't end with a path separator).
110   bool CreateDirectoriesRecursively() const;
111 
112   // Create the directory so that path exists. Returns true if successful or
113   // if the directory already exists; returns false if unable to create the
114   // directory for any reason, including if the parent directory does not
115   // exist. Not named "CreateDirectory" because that's a macro on Windows.
116   bool CreateFolder() const;
117 
118   // Returns true if FilePath describes something in the file-system,
119   // either a file, directory, or whatever, and that something exists.
120   bool FileOrDirectoryExists() const;
121 
122   // Returns true if pathname describes a directory in the file-system
123   // that exists.
124   bool DirectoryExists() const;
125 
126   // Returns true if FilePath ends with a path separator, which indicates that
127   // it is intended to represent a directory. Returns false otherwise.
128   // This does NOT check that a directory (or file) actually exists.
129   bool IsDirectory() const;
130 
131   // Returns true if pathname describes a root directory. (Windows has one
132   // root directory per disk drive.)
133   bool IsRootDirectory() const;
134 
135   // Returns true if pathname describes an absolute path.
136   bool IsAbsolutePath() const;
137 
138  private:
139   // Replaces multiple consecutive separators with a single separator.
140   // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
141   // redundancies that might be in a pathname involving "." or "..".
142   //
143   // A pathname with multiple consecutive separators may occur either through
144   // user error or as a result of some scripts or APIs that generate a pathname
145   // with a trailing separator. On other platforms the same API or script
146   // may NOT generate a pathname with a trailing "/". Then elsewhere that
147   // pathname may have another "/" and pathname components added to it,
148   // without checking for the separator already being there.
149   // The script language and operating system may allow paths like "foo//bar"
150   // but some of the functions in FilePath will not handle that correctly. In
151   // particular, RemoveTrailingPathSeparator() only removes one separator, and
152   // it is called in CreateDirectoriesRecursively() assuming that it will change
153   // a pathname from directory syntax (trailing separator) to filename syntax.
154 
155   void Normalize();
156 
157   String pathname_;
158 };  // class FilePath
159 
160 }  // namespace internal
161 }  // namespace testing
162 
163 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_

164  

 //由h2cc.py生成的 gtest-filepath.cc实现框架

    1 #include "gtest-filepath.h"

  2 
  3 namespace testing {
  4 
  5 namespace internal {
  6 
  7 // Returns the current working directory, or "" if unsuccessful.
  8 FilePath FilePath::GetCurrentDir() 
  9 {
 10 
 11 }
 12 
 13 // Given directory = "dir", base_name = "test", number = 0,
 14 // extension = "xml", returns "dir/test.xml". If number is greater
 15 // than zero (e.g., 12), returns "dir/test_12.xml".
 16 // On Windows platform, uses \ as the separator rather than /.
 17 FilePath FilePath::
 18 MakeFileName(const FilePath& directory,
 19                              const FilePath& base_name,
 20                              int number,
 21                              const char* extension) 
 22 {
 23 
 24 }
 25 
 26 // Given directory = "dir", relative_path = "test.xml",
 27 // returns "dir/test.xml".
 28 // On Windows, uses \ as the separator rather than /.
 29 FilePath FilePath::
 30 ConcatPaths(const FilePath& directory,
 31                             const FilePath& relative_path) 
 32 {
 33 
 34 }
 35 
 36 // Returns a pathname for a file that does not currently exist. The pathname
 37 // will be directory/base_name.extension or
 38 // directory/base_name_<number>.extension if directory/base_name.extension
 39 // already exists. The number will be incremented until a pathname is found
 40 // that does not already exist.
 41 // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
 42 // There could be a race condition if two or more processes are calling this
 43 // function at the same time -- they could both pick the same filename.
 44 FilePath FilePath::
 45 GenerateUniqueFileName(const FilePath& directory,
 46                                        const FilePath& base_name,
 47                                        const char* extension) 
 48 {
 49 
 50 }
 51 
 52 // If input name has a trailing separator character, removes it and returns
 53 // the name, otherwise return the name string unmodified.
 54 // On Windows platform, uses \ as the separator, other platforms use /.
 55 FilePath FilePath::
 56 RemoveTrailingPathSeparator() const 
 57 {
 58 
 59 }
 60 
 61 // Returns a copy of the FilePath with the directory part removed.
 62 // Example: FilePath("path/to/file").RemoveDirectoryName() returns
 63 // FilePath("file"). If there is no directory part ("just_a_file"), it returns
 64 // the FilePath unmodified. If there is no file part ("just_a_dir/") it
 65 // returns an empty FilePath ("").
 66 // On Windows platform, '\' is the path separator, otherwise it is '/'.
 67 FilePath FilePath::RemoveDirectoryName() const 
 68 {
 69 
 70 }
 71 
 72 // RemoveFileName returns the directory path with the filename removed.
 73 // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
 74 // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
 75 // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
 76 // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
 77 // On Windows platform, '\' is the path separator, otherwise it is '/'.
 78 FilePath FilePath::RemoveFileName() const 
 79 {
 80 
 81 }
 82 
 83 // Returns a copy of the FilePath with the case-insensitive extension removed.
 84 // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
 85 // FilePath("dir/file"). If a case-insensitive extension is not
 86 // found, returns a copy of the original FilePath.
 87 FilePath FilePath::
 88 RemoveExtension(const char* extension) const 
 89 {
 90 
 91 }
 92 
 93 // Creates directories so that path exists. Returns true if successful or if
 94 // the directories already exist; returns false if unable to create
 95 // directories for any reason. Will also return false if the FilePath does
 96 // not represent a directory (that is, it doesn't end with a path separator).
 97 bool FilePath::CreateDirectoriesRecursively() const 
 98 {
 99 
100 }
101 
102 // Create the directory so that path exists. Returns true if successful or
103 // if the directory already exists; returns false if unable to create the
104 // directory for any reason, including if the parent directory does not
105 // exist. Not named "CreateDirectory" because that's a macro on Windows.
106 bool FilePath::CreateFolder() const 
107 {
108 
109 }
110 
111 // Returns true if FilePath describes something in the file-system,
112 // either a file, directory, or whatever, and that something exists.
113 bool FilePath::FileOrDirectoryExists() const 
114 {
115 
116 }
117 
118 // Returns true if pathname describes a directory in the file-system
119 // that exists.
120 bool FilePath::DirectoryExists() const 
121 {
122 
123 }
124 
125 // Returns true if FilePath ends with a path separator, which indicates that
126 // it is intended to represent a directory. Returns false otherwise.
127 // This does NOT check that a directory (or file) actually exists.
128 bool FilePath::IsDirectory() const 
129 {
130 
131 }
132 
133 // Returns true if pathname describes a root directory. (Windows has one
134 // root directory per disk drive.)
135 bool FilePath::IsRootDirectory() const 
136 {
137 
138 }
139 
140 // Returns true if pathname describes an absolute path.
141 bool FilePath::IsAbsolutePath() const 
142 {
143 
144 }
145 
146 void FilePath::Normalize() 
147 {
148 
149 }
150 
151 }  // namespace internal
152 
153 }  // namespace testing
154