Command Line Arguments Dev C++

I have not been able to find any documentation on how to process the command line arguments of a C/WinRT, XAML app. In Visual Studio 15.9.6 the application properties do provide a way to enter command line arguments during the development effort, but no way to process them. Command line arguments are optional string arguments that are passed by the operating system to the program when it is launched. The program can then use them as input (or ignore them).

Dev C++ Command Line Parameters

I'm trying to pass arguments to my program so that I can store them into an array. For some reason my IDE/compiler is treating the blank space in between arguments as an argument. I'm using bloodshed, but it doesn't say anything about a seperation character. Can anyone tell me what I'm doing wrong?

I'm doing something like this:
Bob Bill
that should be two parameters, but for some reason it returns three.

Command Line Argument in C. Command line argument is a parameter supplied to the program when it is invoked. Command line argument is an important concept in C programming. It is mostly used when you need to control your program from outside. Command line arguments are passed to the main method. Syntax: int main(int argc, char.argv). Command line arguments in C/C C C Server Side Programming Programming It is possible to pass some values from the command line to your C programs when they are executed. Argtable is an ANSI C library for parsing GNU style command line options with a minimum of fuss. It enables a program's command line syntax to be defined in. Aug 07, 2009 Command-line parameters are passed to a program at runt-time by the operating system when the program is requested by another program, such as a command interpreter ('shell') like cmd.exe on Windows or bash on Linux and OS X. The user types a command and the shell calls the operating system to run the program.

3 Contributors
forum 2 Replies
911 Views
6 Hours Discussion Span
commentLatest Postby Ancient DragonLatest Post

Dante Shamest

It appears to work for me. The version of my Dev-C++ IDE is 4.9.9.2. One should note that the first parameter is always the name of your program.

This is the program I used for testing.

This picture shows how I passed the parameters.

[IMG]http://img438.imageshack.us/img438/724/parameters1fz.th.jpg[/IMG]

And this is my output.

13 Mar 2020CPOL

In this tip, I want to represent a lightweight quick-and-dirty possibility (one of many) for parsing command line arguments on the fly using C++17.

A quick way of parsing command line arguments in modern C++-17 for non-production without using third party header files / libraries. For real world projects, a third party approach is more encouraged.

Introduction

This is intended for small single/couple-file playground-try-like apps.

Background

Very often, by learning new libraries or creating small playground apps (for example, which fit in a single file or a couple of files), I need to parse command line arguments, but don't want mental/time overhead of importing whole libraries (like boost) or lookup third party header files just for that purpose. The work sequence in that scenario is something like this:

Fire VIM, VS, XCode.
Try out some code.
Compile and run with passing some test command line arguments.
If everything clear/OK, goto 2 otherwise goto 5.
Do something else.

Using the Code

As always, when designing some feature or library, I usually go from the use-case first, and then look for appropriate implementation.

The use-case for parsing command line arguments, which I found most convenient for myself, looks something like this:

The MyOpts struct is holding the options which I intend to pass via command line. So in this case, we will have one string option, one int option and one bool option:

Now, those options should have some names. In this case, I want to name my string option opt1, the int option should be named opt2, and the boolean option should be named opt3. The command line in this case would then look like this:

So, the 'some-string-option' should be assigned to MyOpts::stringOpt, 33 should be assigned to MyOpts::intOpt and true should be assigned to MyOpts::boolOpt.

To achieve this, I came up with the following implementation for CmdOpts:

Now let's break this apart:

* CmdOpts is a class template. Its template parameter is type of an object which command line arguments will be assigned to. In the example above, it would be MyOpts.

* The MyProp type alias:

is conceptually a union (std::variant is a C++17 type safe union), where each template parameter is of type pointer to member of Opts. So, at every given timepoint, a variable of type MyProp will hold a pointer to exactly one member of Opts (in our example MyOpts). At this point, we are restricting us to 4 different types: string, int, double and bool. So we are basically saying: every command line argument we pass, will be converted to one of those 4 types. This isn't ideal and could certainly be improved, but remember: we want to keep our implementation minimalistic and simple. And for command line argument, passing those four types would normally be sufficient.

* MyArg will be holding a mapping between option names (for example --opt1) and members of our Opts object (for example, stringOpt), where the values from the command line will be assigned to.

* For every option we will define a callback, so when the option is encountered on the command line, the callback will execute and assign the value to the associated object. So for this, we are holding a mapping between option names and callbacks:

The callback is a function type, whose parameters are the current index of the command line arguments being passed and a view to all available command line arguments. This is needed to get the argument value:

CmdOpts::parse is the main function for our parser. It basically goes over the entire command line arguments and execute each callback in turn. The algorithmic complexity O(n2) is not an issue here, unless we expect to have a big number of command line args, which would be bad use anyway (input file would be more appropriate in this case).

CmdOpts::register_callback sets the callback for the option named name. If the option with this name is encountered, the value is read and written to object property prop. Note: we are using stringstream and variant visitor here, for doing the conversion for different types automatically: every type comfortable with standard inputoperator >> is ok. Note also that boolean input is expected 0 and 1 (instead of false/true).

And that's it! Here's the complete source file for the above example:

Points of Interest

Further possible improvements, would be for example, to make the usage of custom input operators >> and generics for MyProp or to print usage information, but for those more complicated scenarios, it would be more advisable just to use the third party header files / libraries.

Can you come up with some better / more concise implementation, or have some better idea? If so, then please leave comments below.

History

13^th March, 2020: First version