windows 实现 getopt 调用(getopt.h和getopt.c)

源码资源网

windows 实现 getopt 调用(getopt.h和getopt.c)
1、linux系统环境下可以调用getopt
2、windwos系统环境下无法调用getopt
3、windows系统环境下模拟实现getopt

函数说明 getopt() 可以用来分析命令行参数。

1. int getopt(int argc,char * const argv[ ],const char * optstring);

复制代码

参数argc和argv分别代表参数个数和内容，跟main（）函数的命令行参数是一样的。参数 optstring为选项字符串， 告知 getopt()可以处理哪个选项以及哪个选项需要参数，如果选项字符串里的字母后接着冒号“:”，则表示还有相关的参数，全域变量optarg 即会指向此额外参数。

这么好用的函数只能在 Linux 下使用，如果你在 Windows 下进行开发，也想实现命令行可以传入多个自定义参数的功能，这篇文章可以解决你的需求。

将下面两个源文件和头文件加入到你的项目里即可。


getopt.h

1. # ifndef __GETOPT_H_
   
2. # define __GETOPT_H_
   
3. 
   
4. # ifdef _GETOPT_API
   
5. #     undef _GETOPT_API
   
6. # endif
   
7. //------------------------------------------------------------------------------
   
8. # if defined(EXPORTS_GETOPT) && defined(STATIC_GETOPT)
   
9. #     error "The preprocessor definitions of EXPORTS_GETOPT and STATIC_GETOPT \
   
10. can only be used individually"
    
11. # elif defined(STATIC_GETOPT)
    
12. #     pragma message("Warning static builds of getopt violate the Lesser GNU \
    
13. Public License")
    
14. #     define _GETOPT_API
    
15. # elif defined(EXPORTS_GETOPT)
    
16. #     pragma message("Exporting getopt library")
    
17. #     define _GETOPT_API __declspec(dllexport)
    
18. # else
    
19. #     pragma message("Importing getopt library")
    
20. #     define _GETOPT_API __declspec(dllimport)
    
21. # endif
    
22. 
    
23. # include <tchar.h>
    
24. // Standard GNU options
    
25. # define null_argument           0 /*Argument Null*/
    
26. # define no_argument             0 /*Argument Switch Only*/
    
27. # define required_argument       1 /*Argument Required*/
    
28. # define optional_argument       2 /*Argument Optional*/
    
29. // Shorter Versions of options
    
30. # define ARG_NULL 0 /*Argument Null*/
    
31. # define ARG_NONE 0 /*Argument Switch Only*/
    
32. # define ARG_REQ  1 /*Argument Required*/
    
33. # define ARG_OPT  2 /*Argument Optional*/
    
34. // Change behavior for C\C++
    
35. # ifdef __cplusplus
    
36. #     define _BEGIN_EXTERN_C extern "C" {
    
37. #     define _END_EXTERN_C }
    
38. #     define _GETOPT_THROW throw()
    
39. # else
    
40. #     define _BEGIN_EXTERN_C
    
41. #     define _END_EXTERN_C
    
42. #     define _GETOPT_THROW
    
43. # endif
    
44. _BEGIN_EXTERN_C
    
45. extern _GETOPT_API TCHAR *optarg;
    
46. extern _GETOPT_API int    optind;
    
47. extern _GETOPT_API int    opterr;
    
48. extern _GETOPT_API int    optopt;
    
49. struct option
    
50. {
    
51. /* The predefined macro variable __STDC__ is defined for C++, and it has the in-
    
52.    teger value 0 when it is used in an #if statement, indicating that the C++ l-
    
53.    anguage is not a proper superset of C, and that the compiler does not confor-
    
54.    m to C. In C, __STDC__ has the integer value 1. */
    
55. # if defined (__STDC__) && __STDC__
    
56.     const TCHAR* name;
    
57. # else
    
58.     TCHAR* name;
    
59. # endif
    
60.     int has_arg;
    
61.     int *flag;
    
62.     TCHAR val;
    
63. };
    
64. extern _GETOPT_API int getopt( int argc, TCHAR *const *argv
    
65.                              , const TCHAR *optstring ) _GETOPT_THROW;
    
66. extern _GETOPT_API int getopt_long
    
67.                              ( int ___argc, TCHAR *const *___argv
    
68.                              , const TCHAR *__shortopts
    
69.                              , const struct option *__longopts
    
70.                              , int *__longind ) _GETOPT_THROW;
    
71. extern _GETOPT_API int getopt_long_only
    
72.                              ( int ___argc, TCHAR *const *___argv
    
73.                              , const TCHAR *__shortopts
    
74.                              , const struct option *__longopts
    
75.                              , int *__longind ) _GETOPT_THROW;
    
76. // harly.he add for reentrant 12.09/2013
    
77. extern _GETOPT_API void getopt_reset() _GETOPT_THROW;
    
78. _END_EXTERN_C
    
79. // Undefine so the macros are not included
    
80. # undef _BEGIN_EXTERN_C
    
81. # undef _END_EXTERN_C
    
82. # undef _GETOPT_THROW
    
83. # undef _GETOPT_API
    
84. # endif  // __GETOPT_H_

复制代码

getopt.c

1. # ifndef _CRT_SECURE_NO_WARNINGS
   
2. #     define _CRT_SECURE_NO_WARNINGS
   
3. # endif
   
4. 
   
5. # include <stdlib.h>
   
6. # include <stdio.h>
   
7. # include <tchar.h>
   
8. # include "getopt.h"
   
9. 
   
10. # ifdef __cplusplus
    
11. #     define _GETOPT_THROW throw()
    
12. # else
    
13. #     define _GETOPT_THROW
    
14. # endif
    
15. 
    
16. enum ENUM_ORDERING
    
17. {
    
18.     REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
    
19. };
    
20. 
    
21. struct _getopt_data
    
22. {
    
23.     int     optind;
    
24.     int     opterr;
    
25.     int     optopt;
    
26.     TCHAR*  optarg;
    
27.     int     __initialized;
    
28.     TCHAR*  __nextchar;
    
29.     int     __ordering;
    
30.     int     __posixly_correct;
    
31.     int     __first_nonopt;
    
32.     int     __last_nonopt;
    
33. };
    
34. static struct _getopt_data  getopt_data = { 0, 0, 0, NULL, 0, NULL, 0, 0, 0, 0 };
    
35. 
    
36. TCHAR*  optarg  = NULL;
    
37. int     optind  = 1;
    
38. int     opterr  = 1;
    
39. int     optopt  = _T( '?' );
    
40. 
    
41. static void exchange( TCHAR** argv, struct _getopt_data* d )
    
42. {
    
43.     int     bottom  = d->__first_nonopt;
    
44.     int     middle  = d->__last_nonopt;
    
45.     int     top     = d->optind;
    
46.     TCHAR*  tem;
    
47.     while ( top > middle && middle > bottom )
    
48.     {
    
49.         if ( top - middle > middle - bottom )
    
50.         {
    
51.             int len = middle - bottom;
    
52.             register int i;
    
53.             for ( i = 0; i < len; i++ )
    
54.             {
    
55.                 tem = argv[bottom + i];
    
56.                 argv[bottom + i] = argv[top - ( middle - bottom ) + i];
    
57.                 argv[top - ( middle - bottom ) + i] = tem;
    
58.             }
    
59.             top -= len;
    
60.         }
    
61.         else
    
62.         {
    
63.             int len = top - middle;
    
64.             register int i;
    
65.             for ( i = 0; i < len; i++ )
    
66.             {
    
67.                 tem = argv[bottom + i];
    
68.                 argv[bottom + i] = argv[middle + i];
    
69.                 argv[middle + i] = tem;
    
70.             }
    
71.             bottom += len;
    
72.         }
    
73.     }
    
74.     d->__first_nonopt += ( d->optind - d->__last_nonopt );
    
75.     d->__last_nonopt = d->optind;
    
76. }
    
77. 
    
78. static const TCHAR* _getopt_initialize( const TCHAR* optstring
    
79.                                       , struct _getopt_data* d
    
80.                                       , int posixly_correct )
    
81. {
    
82.     d->__first_nonopt = d->__last_nonopt = d->optind;
    
83.     d->__nextchar = NULL;
    
84.     d->__posixly_correct = posixly_correct
    
85.                          | !!_tgetenv( _T( "POSIXLY_CORRECT" ) );
    
86.     if ( optstring[0] == _T( '-' ) )
    
87.     {
    
88.         d->__ordering = RETURN_IN_ORDER;
    
89.         ++optstring;
    
90.     }
    
91.     else if ( optstring[0] == _T( '+' ) )
    
92.     {
    
93.         d->__ordering = REQUIRE_ORDER;
    
94.         ++optstring;
    
95.     }
    
96.     else if ( d->__posixly_correct )
    
97.     {
    
98.         d->__ordering = REQUIRE_ORDER;
    
99.     }
    
100.     else
     
101.     {
     
102.         d->__ordering = PERMUTE;
     
103.     }
     
104.     return optstring;
     
105. }
     
106. 
     
107. int _getopt_internal_r( int argc
     
108.                       , TCHAR *const * argv
     
109.                       , const TCHAR* optstring
     
110.                       , const struct option* longopts
     
111.                       , int* longind
     
112.                       , int long_only
     
113.                       , struct _getopt_data* d
     
114.                       , int posixly_correct )
     
115. {
     
116.     int print_errors    = d->opterr;
     
117.     if ( argc < 1 )
     
118.     {
     
119.         return -1;
     
120.     }
     
121.     d->optarg = NULL;
     
122.     if ( d->optind == 0 || !d->__initialized )
     
123.     {
     
124.         if ( d->optind == 0 )
     
125.         {
     
126.             d->optind = 1;
     
127.         }
     
128.         optstring = _getopt_initialize( optstring, d, posixly_correct );
     
129.         d->__initialized = 1;
     
130.     }
     
131.     else if ( optstring[0] == _T( '-' ) || optstring[0] == _T( '+' ) )
     
132.     {
     
133.         optstring++;
     
134.     }
     
135.     if ( optstring[0] == _T( ':' ) )
     
136.     {
     
137.         print_errors = 0;
     
138.     }
     
139.     if ( d->__nextchar == NULL || *d->__nextchar == _T( '\0' ) )
     
140.     {
     
141.         if ( d->__last_nonopt > d->optind )
     
142.         {
     
143.             d->__last_nonopt = d->optind;
     
144.         }
     
145.         if ( d->__first_nonopt > d->optind )
     
146.         {
     
147.             d->__first_nonopt = d->optind;
     
148.         }
     
149.         if ( d->__ordering == PERMUTE )
     
150.         {
     
151.             if ( d->__first_nonopt != d->__last_nonopt
     
152.               && d->__last_nonopt != d->optind )
     
153.             {
     
154.                 exchange( ( TCHAR * * ) argv, d );
     
155.             }
     
156.             else if ( d->__last_nonopt != d->optind )
     
157.             {
     
158.                 d->__first_nonopt = d->optind;
     
159.             }
     
160.             while ( d->optind
     
161.                   < argc
     
162.                  && ( argv[d->optind][0] != _T( '-' )
     
163.                    || argv[d->optind][1] == _T( '\0' ) ) )
     
164.             {
     
165.                 d->optind++;
     
166.             }
     
167.             d->__last_nonopt = d->optind;
     
168.         }
     
169.         if ( d->optind != argc && !_tcscmp( argv[d->optind], _T( "--" ) ) )
     
170.         {
     
171.             d->optind++;
     
172.             if ( d->__first_nonopt != d->__last_nonopt
     
173.               && d->__last_nonopt != d->optind )
     
174.             {
     
175.                 exchange( ( TCHAR * * ) argv, d );
     
176.             }
     
177.             else if ( d->__first_nonopt == d->__last_nonopt )
     
178.             {
     
179.                 d->__first_nonopt = d->optind;
     
180.             }
     
181.             d->__last_nonopt = argc;
     
182.             d->optind = argc;
     
183.         }
     
184.         if ( d->optind == argc )
     
185.         {
     
186.             if ( d->__first_nonopt != d->__last_nonopt )
     
187.             {
     
188.                 d->optind = d->__first_nonopt;
     
189.             }
     
190.             return -1;
     
191.         }
     
192.         if ( ( argv[d->optind][0] != _T( '-' )
     
193.             || argv[d->optind][1] == _T( '\0' ) ) )
     
194.         {
     
195.             if ( d->__ordering == REQUIRE_ORDER )
     
196.             {
     
197.                 return -1;
     
198.             }
     
199.             d->optarg = argv[d->optind++];
     
200.             return 1;
     
201.         }
     
202.         d->__nextchar = ( argv[d->optind]
     
203.                         + 1 + ( longopts != NULL
     
204.                              && argv[d->optind][1] == _T( '-' ) ) );
     
205.     }
     
206.     if ( longopts != NULL
     
207.         && ( argv[d->optind][1] == _T( '-' )
     
208.             || ( long_only && ( argv[d->optind][2]
     
209.                                 || !_tcschr( optstring, argv[d->optind][1] ) )
     
210.                )
     
211.            )
     
212.         )
     
213.     {
     
214.         TCHAR*                  nameend;
     
215.         const struct option*    p;
     
216.         const struct option*    pfound      = NULL;
     
217.         int                     exact       = 0;
     
218.         int                     ambig       = 0;
     
219.         int                     indfound    = -1;
     
220.         int                     option_index;
     
221.         for ( nameend = d->__nextchar;
     
222.               *nameend && *nameend != _T( '=' );
     
223.               nameend++ )
     
224.             ;
     
225.         for ( p = longopts, option_index = 0; p->name; p++, option_index++ )
     
226.         {
     
227.             if ( !_tcsncmp( p->name, d->__nextchar, nameend - d->__nextchar ) )
     
228.             {
     
229.                 if ( ( unsigned int ) ( nameend - d->__nextchar )
     
230.                   == ( unsigned int ) _tcslen( p->name ) )
     
231.                 {
     
232.                     pfound = p;
     
233.                     indfound = option_index;
     
234.                     exact = 1;
     
235.                     break;
     
236.                 }
     
237.                 else if ( pfound == NULL )
     
238.                 {
     
239.                     pfound = p;
     
240.                     indfound = option_index;
     
241.                 }
     
242.                 else if ( long_only
     
243.                        || pfound->has_arg != p->has_arg
     
244.                        || pfound->flag != p->flag
     
245.                        || pfound->val != p->val )
     
246.                 {
     
247.                          ambig = 1;
     
248.                 }
     
249.             }
     
250.         }
     
251.         if ( ambig && !exact )
     
252.         {
     
253.             if ( print_errors )
     
254.             {
     
255.                 _ftprintf( stderr
     
256.                          , _T( "%s: option '%s' is ambiguous\n" )
     
257.                          , argv[0]
     
258.                          , argv[d->optind] );
     
259.             }
     
260.             d->__nextchar += _tcslen( d->__nextchar );
     
261.             d->optind++;
     
262.             d->optopt = 0;
     
263.             return _T( '?' );
     
264.         }
     
265.         if ( pfound != NULL )
     
266.         {
     
267.             option_index = indfound;
     
268.             d->optind++;
     
269.             if ( *nameend )
     
270.             {
     
271.                 if ( pfound->has_arg )
     
272.                 {
     
273.                     d->optarg = nameend + 1;
     
274.                 }
     
275.                 else
     
276.                 {
     
277.                     if ( print_errors )
     
278.                     {
     
279.                         if ( argv[d->optind - 1][1] == _T( '-' ) )
     
280.                         {
     
281.                             _ftprintf( stderr
     
282.                                      , _T( "%s: option '--%s' doesn't allow " )
     
283.                                        _T( "an argument\n" )
     
284.                                      , argv[0]
     
285.                                      , pfound->name );
     
286.                         }
     
287.                         else
     
288.                         {
     
289.                             _ftprintf( stderr
     
290.                                      , _T( "%s: option '%c%s' doesn't allow " )
     
291.                                        _T( "an argument\n" )
     
292.                                      , argv[0]
     
293.                                      , argv[d->optind - 1][0]
     
294.                                      , pfound->name );
     
295.                         }
     
296.                     }
     
297.                     d->__nextchar += _tcslen( d->__nextchar );
     
298.                     d->optopt = pfound->val;
     
299.                     return _T( '?' );
     
300.                 }
     
301.             }
     
302.             else if ( pfound->has_arg == 1 )
     
303.             {
     
304.                 if ( d->optind < argc )
     
305.                 {
     
306.                     d->optarg = argv[d->optind++];
     
307.                 }
     
308.                 else
     
309.                 {
     
310.                     if ( print_errors )
     
311.                     {
     
312.                         _ftprintf( stderr
     
313.                                  , _T( "%s: option '--%s' requires an " )
     
314.                                    _T( "argument\n" )
     
315.                                  , argv[0]
     
316.                                  , pfound->name );
     
317.                     }
     
318.                     d->__nextchar += _tcslen( d->__nextchar );
     
319.                     d->optopt = pfound->val;
     
320.                     return optstring[0] == _T( ':' ) ? _T( ':' ) : _T( '?' );
     
321.                 }
     
322.             }
     
323.             d->__nextchar += _tcslen( d->__nextchar );
     
324.             if ( longind != NULL )
     
325.             {
     
326.                 *longind = option_index;
     
327.             }
     
328.             if ( pfound->flag )
     
329.             {
     
330.                 *( pfound->flag ) = pfound->val;
     
331.                 return 0;
     
332.             }
     
333.             return pfound->val;
     
334.         }
     
335.         if ( !long_only
     
336.           || argv[d->optind][1]
     
337.           == _T( '-' )
     
338.           || _tcschr( optstring
     
339.                     , *d->__nextchar )
     
340.           == NULL )
     
341.         {
     
342.             if ( print_errors )
     
343.             {
     
344.                 if ( argv[d->optind][1] == _T( '-' ) )
     
345.                 {
     
346.                     /* --option */
     
347.                     _ftprintf( stderr
     
348.                              , _T( "%s: unrecognized option '--%s'\n" )
     
349.                              , argv[0]
     
350.                              , d->__nextchar );
     
351.                 }
     
352.                 else
     
353.                 {
     
354.                     /* +option or -option */
     
355.                     _ftprintf( stderr
     
356.                              , _T( "%s: unrecognized option '%c%s'\n" )
     
357.                              , argv[0]
     
358.                              , argv[d->optind][0]
     
359.                              , d->__nextchar );
     
360.                 }
     
361.             }
     
362.             d->__nextchar = ( TCHAR * ) _T( "" );
     
363.             d->optind++;
     
364.             d->optopt = 0;
     
365.             return _T( '?' );
     
366.         }
     
367.     }
     
368.     {
     
369.         TCHAR   c       = *d->__nextchar++;
     
370.         TCHAR*  temp    = ( TCHAR* ) _tcschr( optstring, c );
     
371.         if ( *d->__nextchar == _T( '\0' ) )
     
372.         {
     
373.             ++d->optind;
     
374.         }
     
375.         if ( temp == NULL || c == _T( ':' ) || c == _T( ';' ) )
     
376.         {
     
377.             if ( print_errors )
     
378.             {
     
379.                 _ftprintf( stderr
     
380.                          , _T( "%s: invalid option -- '%c'\n" )
     
381.                          , argv[0]
     
382.                          , c );
     
383.             }
     
384.             d->optopt = c;
     
385.             return _T( '?' );
     
386.         }
     
387.         if ( temp[0] == _T( 'W' ) && temp[1] == _T( ';' ) )
     
388.         {
     
389.             TCHAR*                  nameend;
     
390.             const struct option*    p;
     
391.             const struct option*    pfound      = NULL;
     
392.             int                     exact       = 0;
     
393.             int                     ambig       = 0;
     
394.             int                     indfound    = 0;
     
395.             int                     option_index;
     
396.             if ( *d->__nextchar != _T( '\0' ) )
     
397.             {
     
398.                 d->optarg = d->__nextchar;
     
399.                 d->optind++;
     
400.             }
     
401.             else if ( d->optind == argc )
     
402.             {
     
403.                 if ( print_errors )
     
404.                 {
     
405.                     _ftprintf( stderr
     
406.                              , _T( "%s: option requires an argument -- '%c'\n" )
     
407.                              , argv[0]
     
408.                              , c );
     
409.                 }
     
410.                 d->optopt = c;
     
411.                 if ( optstring[0] == _T( ':' ) )
     
412.                 {
     
413.                     c = _T( ':' );
     
414.                 }
     
415.                 else
     
416.                 {
     
417.                     c = _T( '?' );
     
418.                 }
     
419.                 return c;
     
420.             }
     
421.             else
     
422.             {
     
423.                 d->optarg = argv[d->optind++];
     
424.             }
     
425.             for ( d->__nextchar = nameend = d->optarg;
     
426.                   *nameend && *nameend != _T( '=' );
     
427.                   nameend++ )
     
428.                 ;
     
429.             for ( p = longopts, option_index = 0;
     
430.                   p->name;
     
431.                   p++, option_index++ )
     
432.             {
     
433.                 if ( !_tcsncmp( p->name
     
434.                               , d->__nextchar
     
435.                               , nameend - d->__nextchar ) )
     
436.                 {
     
437.                     if ( ( unsigned int ) ( nameend - d->__nextchar )
     
438.                       == _tcslen( p->name ) )
     
439.                     {
     
440.                         pfound = p;
     
441.                         indfound = option_index;
     
442.                         exact = 1;
     
443.                         break;
     
444.                     }
     
445.                     else if ( pfound == NULL )
     
446.                     {
     
447.                         pfound = p;
     
448.                         indfound = option_index;
     
449.                     }
     
450.                     else if ( long_only
     
451.                            || pfound->has_arg != p->has_arg
     
452.                            || pfound->flag != p->flag
     
453.                            || pfound->val != p->val )
     
454.                     {
     
455.                              ambig = 1;
     
456.                     }
     
457.                 }
     
458.             }
     
459.             if ( ambig && !exact )
     
460.             {
     
461.                 if ( print_errors )
     
462.                 {
     
463.                     _ftprintf( stderr
     
464.                              , _T( "%s: option '-W %s' is ambiguous\n" )
     
465.                              , argv[0]
     
466.                              , d->optarg );
     
467.                 }
     
468.                 d->__nextchar += _tcslen( d->__nextchar );
     
469.                 d->optind++;
     
470.                 return _T( '?' );
     
471.             }
     
472.             if ( pfound != NULL )
     
473.             {
     
474.                 option_index = indfound;
     
475.                 if ( *nameend )
     
476.                 {
     
477.                     if ( pfound->has_arg )
     
478.                     {
     
479.                         d->optarg = nameend + 1;
     
480.                     }
     
481.                     else
     
482.                     {
     
483.                         if ( print_errors )
     
484.                         {
     
485.                             _ftprintf( stderr
     
486.                                      , _T( "%s: option '-W %s' doesn't allow " )
     
487.                                        _T( "an argument\n" )
     
488.                                      , argv[0]
     
489.                                      , pfound->name );
     
490.                         }
     
491.                         d->__nextchar += _tcslen( d->__nextchar );
     
492.                         return _T( '?' );
     
493.                     }
     
494.                 }
     
495.                 else if ( pfound->has_arg == 1 )
     
496.                 {
     
497.                     if ( d->optind < argc )
     
498.                     {
     
499.                         d->optarg = argv[d->optind++];
     
500.                     }
     
501.                     else
     
502.                     {
     
503.                         if ( print_errors )
     
504.                         {
     
505.                             _ftprintf( stderr
     
506.                                      , _T( "%s: option '-W %s' requires an " )
     
507.                                        _T( "argument\n" )
     
508.                                      , argv[0]
     
509.                                      , pfound->name );
     
510.                         }
     
511.                         d->__nextchar += _tcslen( d->__nextchar );
     
512.                         return optstring[0] == _T(':') ? _T(':') : _T('?');
     
513.                     }
     
514.                 }
     
515.                 else
     
516.                 {
     
517.                     d->optarg = NULL;
     
518.                 }
     
519.                 d->__nextchar += _tcslen( d->__nextchar );
     
520.                 if ( longind != NULL )
     
521.                 {
     
522.                     *longind = option_index;
     
523.                 }
     
524.                 if ( pfound->flag )
     
525.                 {
     
526.                     *( pfound->flag ) = pfound->val;
     
527.                     return 0;
     
528.                 }
     
529.                 return pfound->val;
     
530.             }
     
531.             d->__nextchar = NULL;
     
532.             return _T( 'W' );
     
533.         }
     
534.         if ( temp[1] == _T( ':' ) )
     
535.         {
     
536.             if ( temp[2] == _T( ':' ) )
     
537.             {
     
538.                 if ( *d->__nextchar != _T( '\0' ) )
     
539.                 {
     
540.                     d->optarg = d->__nextchar;
     
541.                     d->optind++;
     
542.                 }
     
543.                 else
     
544.                 {
     
545.                     d->optarg = NULL;
     
546.                 }
     
547.                 d->__nextchar = NULL;
     
548.             }
     
549.             else
     
550.             {
     
551.                 if ( *d->__nextchar != _T( '\0' ) )
     
552.                 {
     
553.                     d->optarg = d->__nextchar;
     
554.                     d->optind++;
     
555.                 }
     
556.                 else if ( d->optind == argc )
     
557.                 {
     
558.                     if ( print_errors )
     
559.                     {
     
560.                         _ftprintf( stderr
     
561.                                  , _T( "%s: option requires an " )
     
562.                                    _T( "argument -- '%c'\n" )
     
563.                                  , argv[0]
     
564.                                  , c );
     
565.                     }
     
566.                     d->optopt = c;
     
567.                     if ( optstring[0] == _T( ':' ) )
     
568.                     {
     
569.                         c = _T( ':' );
     
570.                     }
     
571.                     else
     
572.                     {
     
573.                         c = _T( '?' );
     
574.                     }
     
575.                 }
     
576.                 else
     
577.                 {
     
578.                     d->optarg = argv[d->optind++];
     
579.                 }
     
580.                 d->__nextchar = NULL;
     
581.             }
     
582.         }
     
583.         return c;
     
584.     }
     
585. }
     
586. 
     
587. int _getopt_internal( int argc
     
588.                     , TCHAR *const * argv
     
589.                     , const TCHAR* optstring
     
590.                     , const struct option* longopts
     
591.                     , int* longind
     
592.                     , int long_only
     
593.                     , int posixly_correct )
     
594. {
     
595.     int result;
     
596.     getopt_data.optind = optind;
     
597.     getopt_data.opterr = opterr;
     
598.     result = _getopt_internal_r( argc
     
599.                                , argv
     
600.                                , optstring
     
601.                                , longopts
     
602.                                , longind
     
603.                                , long_only
     
604.                                , &getopt_data
     
605.                                , posixly_correct );
     
606.     optind = getopt_data.optind;
     
607.     optarg = getopt_data.optarg;
     
608.     optopt = getopt_data.optopt;
     
609.     return result;
     
610. }
     
611. 
     
612. int getopt( int argc, TCHAR *const * argv, const TCHAR* optstring) _GETOPT_THROW
     
613. {
     
614.     return _getopt_internal( argc
     
615.                            , argv
     
616.                            , optstring
     
617.                            , ( const struct option * ) 0
     
618.                            , ( int * ) 0
     
619.                            , 0
     
620.                            , 0 );
     
621. }
     
622. 
     
623. int getopt_long( int argc
     
624.                , TCHAR *const * argv
     
625.                , const TCHAR* options
     
626.                , const struct option* long_options
     
627.                , int* opt_index ) _GETOPT_THROW
     
628. {
     
629.     return _getopt_internal( argc
     
630.                            , argv
     
631.                            , options
     
632.                            , long_options
     
633.                            , opt_index
     
634.                            , 0
     
635.                            , 0 );
     
636. }
     
637. 
     
638. int _getopt_long_r( int argc
     
639.                   , TCHAR *const * argv
     
640.                   , const TCHAR* options
     
641.                   , const struct option* long_options
     
642.                   , int* opt_index
     
643.                   , struct _getopt_data* d )
     
644. {
     
645.     return _getopt_internal_r( argc
     
646.                              , argv
     
647.                              , options
     
648.                              , long_options
     
649.                              , opt_index
     
650.                              , 0
     
651.                              , d
     
652.                              , 0 );
     
653. }
     
654. 
     
655. int getopt_long_only( int argc
     
656.                     , TCHAR *const * argv
     
657.                     , const TCHAR* options
     
658.                     , const struct option* long_options
     
659.                     , int* opt_index ) _GETOPT_THROW
     
660. {
     
661.     return _getopt_internal( argc
     
662.                            , argv
     
663.                            , options
     
664.                            , long_options
     
665.                            , opt_index
     
666.                            , 1
     
667.                            , 0 );
     
668. }
     
669. 
     
670. int _getopt_long_only_r( int argc
     
671.                        , TCHAR *const * argv
     
672.                        , const TCHAR* options
     
673.                        , const struct option* long_options
     
674.                        , int* opt_index
     
675.                        , struct _getopt_data* d )
     
676. {
     
677.     return _getopt_internal_r( argc
     
678.                              , argv
     
679.                              , options
     
680.                              , long_options
     
681.                              , opt_index
     
682.                              , 1
     
683.                              , d
     
684.                              , 0 );
     
685. }
     
686. 
     
687. void getopt_reset()
     
688. {
     
689.     optarg  = NULL;
     
690.     optind  = 1;
     
691.     opterr  = 1;
     
692.     optopt  = _T( '?' );
     
693.     //
     
694.     getopt_data.optind            = 0;
     
695.     getopt_data.opterr            = 0;
     
696.     getopt_data.optopt            = 0;
     
697.     getopt_data.optarg            = NULL;
     
698.     getopt_data.__initialized     = 0;
     
699.     getopt_data.__nextchar        = NULL;
     
700.     getopt_data.__ordering        = 0;
     
701.     getopt_data.__posixly_correct = 0;
     
702.     getopt_data.__first_nonopt    = 0;
     
703.     getopt_data.__last_nonopt     = 0;
     
704. }

复制代码

示例test_getopt.c:

1. # include <tchar.h>
   
2. # include <ctype.h>
   
3. # include <stdio.h>
   
4. # include <stdlib.h>
   
5. # include "getopt.h"
   
6. 
   
7. int _tmain(int argc, TCHAR **argv)
   
8. {
   
9.     int aflag = 0;
   
10.     int bflag = 0;
    
11.     TCHAR *cvalue = NULL;
    
12.     int index;
    
13.     int c;
    
14.     opterr = 0;
    
15.     while((c = getopt(argc,argv, _T("abc:"))) != -1)
    
16.     switch(c)
    
17.     {
    
18.     case 'a':
    
19.         aflag = 1;
    
20.         break;
    
21.     case 'b':
    
22.         bflag = 1;
    
23.         break;
    
24.     case 'c':
    
25.         cvalue = optarg;
    
26.         break;
    
27.     case '?':
    
28.         if(optopt == 'c')
    
29.             _ftprintf(stderr,_T("Option -%c requires an argument.\n"),optopt);
    
30.         else if(isprint(optopt))
    
31.             _ftprintf(stderr,_T("Unknown option `-%c'.\n"),optopt);
    
32.         else
    
33.             _ftprintf(stderr,_T("Unknown option character `\\x%x'.\n"),optopt);
    
34.         return 1;
    
35.     default:
    
36.         abort();
    
37.     }
    
38.     _tprintf(_T("aflag = %d, bflag = %d, cvalue = %s\n"), aflag,bflag,cvalue);
    
39.     for(index = optind; index < argc; index++)
    
40.         _tprintf(_T("Non-option argument %s\n"),argv[index]);
    
41.     return 0;
    
42. }

复制代码