设为首页收藏本站
天气与日历 切换到窄版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

此广告位出租
帆帆资源网»首页 › 编程教程 › 编程教程 › windows 实现 getopt 调用(getopt.h和getopt.c)
返回列表 发新帖
查看: 348|回复: 0

[C++教程] windows 实现 getopt 调用(getopt.h和getopt.c)

[复制链接]
帆帆资源网

3188

主题

4

回帖

3290

积分

管理员

积分
3290
发表于 2024-2-26 13:18:34 | 显示全部楼层 |阅读模式
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_

  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

  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

  5. # include <stdlib.h>
  6. # include <stdio.h>
  7. # include <tchar.h>
  8. # include "getopt.h"

  10. # ifdef __cplusplus
  11. #     define _GETOPT_THROW throw()
  12. # else
  13. #     define _GETOPT_THROW
  14. # endif

  16. enum ENUM_ORDERING
  17. {
  18.     REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
  19. };

  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 };

  36. TCHAR*  optarg  = NULL;
  37. int     optind  = 1;
  38. int     opterr  = 1;
  39. int     optopt  = _T( '?' );

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }
复制代码


gt, if, quot, argv, nonopt

相关帖子

扫码关注微信公众号，及时获取最新资源信息！【下载附件优惠：VIP会员5折；永久VIP免费】
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

免责声明：
1、本站提供的所有资源仅供参考学习使用，版权归原著所有，禁止下载本站资源参与商业和非法行为，请在24小时之内自行删除！
2、本站所有内容均由互联网收集整理、网友上传，并且以计算机技术研究交流为目的，仅供大家参考、学习，请勿任何商业目的与商业用途。
3、若您需要商业运营或用于其他商业活动，请您购买正版授权并合法使用。
4、论坛的所有内容都不保证其准确性，完整性，有效性，由于源码具有复制性，一经售出，概不退换。阅读本站内容因误导等因素而造成的损失本站不承担连带责任。
5、用户使用本网站必须遵守适用的法律法规,对于用户违法使用本站非法运营而引起的一切责任，由用户自行承担
6、本站所有资源来自互联网转载，版权归原著所有，用户访问和使用本站的条件是必须接受本站“免责声明”，如果不遵守，请勿访问或使用本网站
7、本站使用者因为违反本声明的规定而触犯中华人民共和国法律的，一切后果自己负责，本站不承担任何责任。
8、凡以任何方式登陆本网站或直接、间接使用本网站资料者，视为自愿接受本网站声明的约束。
9、本站以《2013 中华人民共和国计算机软件保护条例》第二章 “软件著作权” 第十七条为原则：为了学习和研究软件内含的设计思想和原理，通过安装、显示、传输或者存储软件等方式使用软件的，可以不经软件著作权人许可，不向其支付报酬。若有学员需要商用本站资源，请务必联系版权方购买正版授权！
10、本网站如无意中侵犯了某个企业或个人的知识产权，请来信【站长信箱312337667@qq.com】告之，本站将立即删除。
郑重声明：
本站所有资源仅供用户本地电脑学习源代码的内含设计思想和原理，禁止任何其他用途！
本站所有资源、教程来自互联网转载，仅供学习交流，不得商业运营资源，不确保资源完整性，图片和资源仅供参考，不提供任何技术服务。
本站资源仅供本地编辑研究学习参考，禁止未经资源商正版授权参与任何商业行为，违法行为！如需商业请购买各资源商正版授权
本站仅收集资源，提供用户自学研究使用，本站不存在私自接受协助用户架设游戏或资源，非法运营资源行为。
快速回复 返回顶部 返回列表