C++: Command Line Processing

Save this code here for studying and using it.

Surce code is here.

CmdLine.h File

#pragma once
#include "unicodemacro.h"
#include <vector>
#include <map>

namespace Utility
{

    // handy little container for our argument vector
    struct   CmdParam {
        std::vector<tstring> strings_;
    };

    /**
    A utility for parsing command lines.

    This was originally written by Chris Losinger, changes were simply
    removing the inheritance from std::map<>, and adding a map as a member
    variable instead. then all the VCF related String was replaced with
    tstring and can suite both unicode and non-unicode string

    Example :

    Our example application uses a command line that has two
    required switches and two optional switches. The app should abort
    if the required switches are not present and continue with default
    values if the optional switches are not present.

    Sample command line :
    MyApp.exe -p1 text1 text2 -p2 "this is a big argument" -opt1 -55 -opt2

    Switches -p1 and -p2 are required.
    p1 has two arguments and p2 has one.

    Switches -opt1 and -opt2 are optional.
    opt1 requires a numeric argument.
    opt2 has no arguments.

    Also, assume that the app displays a 'help' screen if the '-h' switch
    is present on the command line.

    \code
#include "cmdline.h"
using namespace Utility;
using namespace std;
void show_help()
{
    tcout<< _T("This is a help string") <<endl;
}
int _tmain(int argc, _TCHAR* argv[])
{
    CommandLine cmdLine;
    // parse argc,argv
    if (cmdLine.SplitLine(argc, argv) < 1)
    {
        // no switches were given on the command line, abort
        ASSERT(0);
        exit(-1);
    }

    // test for the 'help' case
    if (cmdLine.HasSwitch( _T("-h") ) )
    {
        show_help();
        exit(0);
    }

    // get the required arguments
    tstring p1_1, p1_2, p2_1;
    try
    {
        // if any of these fail, we'll end up in the catch() block
        p1_1 = cmdLine.GetArgument( _T("-p1") , 0);
        p1_2 = cmdLine.GetArgument( _T("-p1") , 1);
        p2_1 = cmdLine.GetArgument( _T("-p2") , 0);

    }
    catch (...)
    {
        // one of the required arguments was missing, abort
        ASSERT(0);
        exit(-1);
    }

    // get the optional parameters

    // convert to an int, default to '-1'
    int iOpt1Val =    tstoi( cmdLine.GetSafeArgument( _T("-optInt"), 0, _T("-1") ).c_str() );
    tcout<<iOpt1Val<<endl;
    return 0;
}
    \endcode
    @version 1.0 Chris Losinger
    @version 2.0 Jim Crafton
    @version 3.0 Marshall Wei
    */
    class   CommandLine
    {
    public:
        typedef std::map<tstring, CmdParam> CommandLineMap;
        typedef std::vector<tstring> CommandLineVector;

        CommandLine() {}
        virtual ~CommandLine() {}
        /**
        parse the command line into switches and arguments.
        @return int number of switches found
        */
        int SplitLine( int argc, TCHAR **argv );

        int SplitLine( const tstring& commandLine );

        int SplitLine( const std::vector<tstring>& commandLine );

        /**
        was the switch found on the command line ?
        \code
        ex. if the command line is : app.exe -a p1 p2 p3 -b p4 -c -d p5

        call                          return
        ----                          ------
        cmdLine.HasSwitch("-a")       true
        cmdLine.HasSwitch("-z")       false
        \endcode
        @return bool true if it has the swith, otherwise false
        */
        bool HasSwitch( const tstring& aSwitch ) const ;

        /**
        fetch an argument associated with a switch . if the parameter at
        index iIdx is not found, this will return the default that you
        provide.

        example :
        \code
        command line is : app.exe -a p1 p2 p3 -b p4 -c -d p5

        call                                      return
        ----                                      ------
        cmdLine.GetSafeArgument("-a", 0, "zz")    p1
        cmdLine.GetSafeArgument("-a", 1, "zz")    p2
        cmdLine.GetSafeArgument("-b", 0, "zz")    p4
        cmdLine.GetSafeArgument("-b", 1, "zz")    zz
        \endcode
        */

        tstring GetSafeArgument(const tstring& aSwitch, size_t iIdx, const tstring& aDefault) const;

        /**
        fetch a argument associated with a switch. throws an exception
        of (int)0, if the parameter at index iIdx is not found.

        example :
        \code
        command line is : app.exe -a p1 p2 p3 -b p4 -c -d p5

        call                             return
        ----                             ------
        cmdLine.GetArgument("-a", 0)     p1
        cmdLine.GetArgument("-b", 1)     throws (int)0, returns an empty string
        \endcode
        */
        tstring GetArgument( const tstring& aSwitch, size_t iIdx ) const;

        tstring GetArgument( size_t index ) const;

        /**
        @return the number of arguments found for a given switch. -1 if the
        switch was not found
        */
        int GetArgumentCount(const tstring& aSwitch) const;

        size_t GetArgCount() const {
            return m_originalCommandLine.size();
        }

        const std::vector<tstring>& GetOriginalCommandLine() const
        {
            return m_originalCommandLine;
        }
    protected:
        /**
        protected member function
        test a parameter to see if it's a switch :
        switches are of the form : -x
        where 'x' is one or more characters.
        the first character of a switch must be non-numeric!
        */
        bool IsSwitch(const tstring& param) const;

        CommandLineMap            m_commandLine;
        CommandLineVector         m_originalCommandLine;
    };

}

CmdLine.cpp file

#include "stdafx.h"
#include "cmdline.h"

using namespace std;

namespace Utility
{
    int CommandLine::SplitLine( const std::vector<tstring>& commandLine )
    {
        m_commandLine.clear();
        m_originalCommandLine.clear();

        m_originalCommandLine = commandLine;

        tstring curParam; // current argv[x]
        size_t argc = m_originalCommandLine.size();
        // skip the exe name (start with i = 1)
        for (size_t i = ; i < argc; i++)  {
            // if it's a switch, start a new CommandLine
            if ( IsSwitch(m_originalCommandLine[i]))  {
                curParam = m_originalCommandLine[i];

                tstring arg;

                // look at next input tstring to see if it's a switch or an argument
                if (i +  < argc)  {
                    if (!IsSwitch(m_originalCommandLine[i + ])) {
                        // it's an argument, not a switch
                        arg = m_originalCommandLine[i + ];

                        // skip to next
                        i++;
                    }
                    else {
                        arg = _T("");
                    }
                }

                // add it
                CmdParam cmd;

                // only add non-empty args
                if (arg != _T("") )  {
                    cmd.strings_.push_back(arg);
                }

                // add the CmdParam to 'this'
                std::pair<CommandLineMap::iterator, bool> res = m_commandLine.insert(CommandLineMap::value_type(curParam, cmd));

            }
            else  {
                // it's not a new switch, so it must be more stuff for the last switch

                // ...let's add it
                CommandLineMap::iterator theIterator;

                // get an iterator for the current param
                theIterator = m_commandLine.find(curParam);
                if (theIterator!=m_commandLine.end())  {
                    (*theIterator).second.strings_.push_back(m_originalCommandLine[i]);
                }
                else  {
                    // ??
                }
            }
        }

        return static_cast<int>( m_commandLine.size() );
    }

    int CommandLine::SplitLine( int argc, TCHAR **argv )
    {
        std::vector<tstring> args;

        for ( int j=;j<argc;j++ ) {
            args.push_back( tstring(argv[j]) );
        }

        return SplitLine( args );
    }

    int CommandLine::SplitLine( const tstring& commandLine )
    {
        std::vector<tstring> args;
        const TCHAR* P = commandLine.c_str();
        const TCHAR* start = P;
        const TCHAR* argStart = P;

        int sz = static_cast<int>( commandLine.size() );
        while ( (P - start) < sz ) {
            if ( *P == '\"' ) {
                P++;
                while ( ((P - start) < sz) && (*P != '\"' ) ) {
                    P++;
                }
                P++;
            }

            if ( *P == '\"' ) {
                continue; //loop again
            }

            if ( *P == ' ' ) {
                //argument
                //strip out begin/end quotes

                tstring arg;
                const TCHAR* tmpArgStart = argStart;
                const TCHAR* tmpArgEnd = tmpArgStart;
                while ( tmpArgEnd < P ) {
                    if ( *tmpArgEnd == '\"' ) {
                        if ( tmpArgStart != tmpArgEnd ) {
                            arg.append( tmpArgStart, tmpArgEnd - tmpArgStart );
                            tmpArgStart = tmpArgEnd;
                        }
                        tmpArgStart++;
                    }

                    tmpArgEnd ++;
                }

                if ( arg.empty() ) {
                    arg.append( tmpArgStart, tmpArgEnd - tmpArgStart );
                }

                args.push_back( arg );

                while ( (*P == ' ') && ((P - start) < sz) ) {
                    P++;
                }
                argStart = P;
                P--;
            }

            P++;
        }
        if ( argStart < P ) {
            tstring arg;
            arg.assign( argStart, P-argStart );
            args.push_back( arg );
        }

        return SplitLine( args );
    }

    bool CommandLine::IsSwitch(const tstring& aParam) const
    {
        if (aParam.empty())
            return false;

        // switches must non-empty
        // must have at least one character after the '-'

        if (aParam.size() <= )  {
            return false;
        }

        // switches always start with '-'
        if (aParam[]=='-')   {
            // allow negative numbers as arguments.
            // ie., don't count them as switches
            return (!isdigit(aParam[]));
        }
        else   {
            return false;
        }
    }

    bool CommandLine::HasSwitch(const tstring& aSwitch) const
    {
        CommandLineMap::const_iterator theIterator;
        theIterator = m_commandLine.find(aSwitch);
        return (theIterator != m_commandLine.end());
    }

    tstring CommandLine::GetSafeArgument(const tstring& aSwitch, size_t index, const tstring& defaultVal) const
    {
        tstring result;

        if ( !defaultVal.empty() ) {
            result = defaultVal;
        }

        try
        {
            result = GetArgument(aSwitch, index);
        }
        catch (...)
        {
        }

        return result;
    }

    tstring CommandLine::GetArgument( size_t index ) const
    {
        tstring result;
        if ( (index >= ) && (index < m_originalCommandLine.size()) ) {
            result = m_originalCommandLine[index];
        }
        return result;
    }

    tstring CommandLine::GetArgument( const tstring& aSwitch, size_t index )const
    {
        if ( HasSwitch( aSwitch ) )
        {
            CommandLineMap::const_iterator theIterator = m_commandLine.find(aSwitch);
            if (theIterator!=m_commandLine.end())
            {
                if ((*theIterator).second.strings_.size() > index)
                {
                    return (*theIterator).second.strings_[index];
                }
            }
        }

        throw (int);

        return _T("");
    }

    int CommandLine::GetArgumentCount(const tstring& aSwitch) const
    {
        int result = -;

        if ( HasSwitch(aSwitch) )  {
            CommandLineMap::const_iterator theIterator = m_commandLine.find( aSwitch );
            if (theIterator!=m_commandLine.end())      {
                result = static_cast<int>( (*theIterator).second.strings_.size() );
            }
        }

        return result;
    }
}