| Home | Libraries | People | FAQ | More

## Reference

### Header <boost/program_options/cmdline.hpp>

    namespace boost {
      namespace program_options {
        namespace command_line_style {
          enum style_t;
        }
      }
    }

### Header <boost/program_options/config.hpp>

    BOOST_PROGRAM_OPTIONS_DECL

### Header <boost/program_options/environment_iterator.hpp>

    namespace boost {
      class environment_iterator;
    }

### Header <boost/program_options/eof_iterator.hpp>

    namespace boost {
      template<typename Derived, typename ValueType> class eof_iterator;
    }

### Header <boost/program_options/errors.hpp>

    namespace boost {
      namespace program_options {
        class ambiguous_option;
        class error;
        class error_with_no_option_name;
        class error_with_option_name;
        class invalid_bool_value;
        class invalid_command_line_style;
        class invalid_command_line_syntax;
        class invalid_config_file_syntax;
        class invalid_option_value;
        class invalid_syntax;
        class multiple_occurrences;
        class multiple_values;
        class reading_file;
        class required_option;
        class too_many_positional_options_error;
        class unknown_option;
        class validation_error;
        std::string strip_prefixes(const std::string & text);
      }
    }

### Header <boost/program_options/option.hpp>

    namespace boost {
      namespace program_options {
        template<typename charT> class basic_option;

        typedef basic_option< char > option;
        typedef basic_option< wchar_t > woption;
      }
    }

### Header <boost/program_options/options_description.hpp>

    namespace boost {
      namespace program_options {
        class duplicate_option_error;
        class option_description;
        class options_description;
        class options_description_easy_init;
      }
    }

### Header <boost/program_options/parsers.hpp>

    namespace boost {
      namespace program_options {
        template<typename charT> class basic_command_line_parser;

        template<> class basic_parsed_options<wchar_t>;

        enum collect_unrecognized_mode;

        typedef basic_parsed_options< char > parsed_options;
        typedef basic_parsed_options< wchar_t > wparsed_options;
        typedef function1< std::pair< std::string, std::string >, const std::string & > ext_parser;
        typedef basic_command_line_parser< char > command_line_parser;
        typedef basic_command_line_parser< wchar_t > wcommand_line_parser;
        template<typename charT>
          basic_parsed_options< charT >
          parse_command_line(int, const charT *const, const options_description &,
                             int = 0,
                             function1< std::pair< std::string, std::string >, const std::string & > = ext_parser());
        template<typename charT>
          BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options< charT >
          parse_config_file(std::basic_istream< charT > &,
                            const options_description &, bool = false);
        template<typename charT>
          BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options< charT >
          parse_config_file(const char *, const options_description &,
                            bool = false);
        template<typename charT>
          std::vector< std::basic_string< charT > >
          collect_unrecognized(const std::vector< basic_option< charT > > &,
                               enum collect_unrecognized_mode);
        BOOST_PROGRAM_OPTIONS_DECL parsed_options
        parse_environment(const options_description &,
                          const function1< std::string, std::string > &);
        BOOST_PROGRAM_OPTIONS_DECL parsed_options
        parse_environment(const options_description &, const std::string &);
        BOOST_PROGRAM_OPTIONS_DECL parsed_options
        parse_environment(const options_description &, const char *);
        BOOST_PROGRAM_OPTIONS_DECL std::vector< std::string >
        split_unix(const std::string &, const std::string & = " \t",
                   const std::string & = "'\"", const std::string & = "\\");
        BOOST_PROGRAM_OPTIONS_DECL std::vector< std::wstring >
        split_unix(const std::wstring &, const std::wstring & = L" \t",
                   const std::wstring & = L"'\"", const std::wstring & = L"\\");
      }
    }

### Header <boost/program_options/positional_options.hpp>

    namespace boost {
      namespace program_options {
        class positional_options_description;
      }
    }

### Header <boost/program_options/value_semantic.hpp>

    namespace boost {
      namespace program_options {
        template<typename T, typename charT = char> class typed_value;
        class typed_value_base;
        class untyped_value;
        class value_semantic;
        template<typename charT> class value_semantic_codecvt_helper;

        template<> class value_semantic_codecvt_helper<char>;
        template<> class value_semantic_codecvt_helper<wchar_t>;
        template<typename T> typed_value< T > * value();
        template<typename T> typed_value< T > * value(T *);
        template<typename T> typed_value< T, wchar_t > * wvalue();
        template<typename T> typed_value< T, wchar_t > * wvalue(T *);
        BOOST_PROGRAM_OPTIONS_DECL typed_value< bool > * bool_switch();
        BOOST_PROGRAM_OPTIONS_DECL typed_value< bool > * bool_switch(bool *);
      }
    }

### Header <boost/program_options/variables_map.hpp>

    namespace boost {
      namespace program_options {
        class abstract_variables_map;
        class variable_value;
        class variables_map;
        BOOST_PROGRAM_OPTIONS_DECL void
        store(const basic_parsed_options< char > &, variables_map &, bool = false);
        BOOST_PROGRAM_OPTIONS_DECL void
        store(const basic_parsed_options< wchar_t > &, variables_map &);
        BOOST_PROGRAM_OPTIONS_DECL void notify(variables_map &);
      }
    }

### Header <boost/program_options/version.hpp>

    BOOST_PROGRAM_OPTIONS_VERSION