argv[] comparison

[kaferro]

What is the safest way to make an argv[] comparison? The code below
works.

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
string test;

if(argc>1)
test = argv[1];

if(test=="NKDT" )
cout << "\nComparis on is true. Have program do something.\n";
else
cout << "\nComparis on is false. Have program do something else.\n";

return 0;
}

[Alf P. Steinbach]

* ka*****@hotmail .com:

What is the safest way to make an argv[] comparison? The code below
works.

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
string test;

if(argc>1)
test = argv[1];

if(test=="NKDT" )
cout << "\nComparis on is true. Have program do something.\n";
else
cout << "\nComparis on is false. Have program do something else.\n";

return 0;
}

Do the following:

#include <iostream>

#include <cstddef>
#include <string>
#include <vector>
#include <stdexcept>

typedef std::vector<std ::stringStringV ector;

bool throwX( char const s[] ) { throw std::runtime_er ror( s ); }

void cppMain( StringVector const& arguments )
{
arguments.size( ) 1
|| throwX( "usage: myprog ARG1" );

if( arguments.at(1) == "NKDT" )
{
// Do something.
}
else
{
// Do something else.
}
}

int main( int n, char* a[] )
{
try
{
cppMain( StringVector( a, a+n ) );
return EXIT_SUCCESS;
}
catch( std::exception const& x )
{
std::cerr << "!" << x.what() << std::endl;
return EXIT_FAILURE;
}
}
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[dave_mikesell]

On May 21, 2:39 pm, "Alf P. Steinbach" <[e-mail] rote:

* kafe...@hotmail .com:

What is the safest way to make an argv[] comparison? The code below
works.

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
string test;

if(argc>1)
test = argv[1];

if(test=="NKDT" )
cout << "\nComparis on is true. Have program do something.\n";
else
cout << "\nComparis on is false. Have program do something else.\n";

return 0;
}

Do the following:

<snip>

What was wrong with the OP's solution, which appeared to be much more
concise?

[Alf P. Steinbach]

* da***********@f astmail.fm:

On May 21, 2:39 pm, "Alf P. Steinbach" <[e-mail] rote:

>* kafe...@hotmail .com:

>>>
What is the safest way to make an argv[] comparison? The code below
works.
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char *argv[])
{
string test;
if(argc>1)
test = argv[1];
if(test=="NKDT" )
cout << "\nComparis on is true. Have program do something.\n";
else
cout << "\nComparis on is false. Have program do something else.\n";
return 0;
}

Do the following:

<snip>

What was wrong with the OP's solution, which appeared to be much more
concise?

Probably directly wrong: always indicating success for the program
execution. Also probably directly wrong: doesn't handle exceptions.
However, one might design a program so that no exception should ever
propagate up to main and if it does one wants termination for ease of
debugging, not a report and failure indication. So it depends on design
and methodology and toolchain and to some extent personal preference.
But I don't think the lack of exception handling here was intentional.

Ungood: the main code has direct access to argc and argv, when the aim
is to handle them in "the safest way" (giving access is unsafe). Also
ungood in general: "using namespace std:;". Also ungood: not using
curly braces for nested statements (just about any style guideline will
tell you to use them, always, in order to support maintenance).

Appearance of conciseness: all of the OP's code is program-specific,
whereas the code I listed is mostly boilerplate, a kind of
micro-framework for this particular kind of small student program or
professional's check-it-out program or single-use personal tool program.
For consisness one could write e.g. (doing the /same/ as the OP's code)

#include <string>
#include <iostream>
int main( int n, char* a[] )
{
using namespace std;
n 1 && std::string( a[1] ) == "NKDT"
? cout << "\nComparis on is true. Something.\n"
: cout << "\nComparis on is false. Something else.\n";
}

getting rid of the local variable 'test' and also the 'return 0' which
is implied (it's the default) in 'main', and just to make it extra
concise I also removed that darned 'else' which otherwise would use up a
very expensive line, and the keyword 'if' which is so much to read. I
simply don't understand why so many programmers think conciseness is a
goal. They just end up not understanding their own code.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[James Kanze]

On May 21, 8:31 pm, "kafe...@hotmai l.com" <kafe...@hotmai l.comwrote:

What is the safest way to make an argv[] comparison? The code below
works.

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
string test;

if(argc>1)
test = argv[1];

if(test=="NKDT" )
cout << "\nComparis on is true. Have program do something.\n";
else
cout << "\nComparis on is false. Have program do somethingelse.\ n";
return 0;
}

It depends on context. For simply "quicky" programs, I just do
it as I did in C, something like:

if ( argc 1 && strcmp( argc[ 1 ], "NKDT" ) == 0 ) {
// ...
}

As soon as the program ceases to be trivial, however, I'll use a
library based solution which strips out the options, and exposes
the remaining arguments as a std::vector<std ::string>, or
something similar. Thus, my own code would be something like:

int
main( int argc, char** argv )
{
Gabi::CommandLi ne& args( Gabi::CommandLi ne::instance() ) ;
args.parse( argc, argv ) ;
if ( args.size() 1 && args[ i ] == "NKDT" ) {
// ...
} else {
// ...
}
return Gabi::ProgramSt atus::returnCod e() ;
}

Such binary selections are more often handled by means of
options, however:

int
main( int argc, char** argv )
{
Gabi::BooleanOp tion isNKDT( "NKDT" ) ;
Gabi::CommandLi ne& args( Gabi::CommandLi ne::instance() ) ;
args.parse( argc, argv ) ;
if ( isNKDT ) {
// ...
} else {
// ...
}
return Gabi::ProgramSt atus::returnCod e() ;
}

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Gianni Mariani]

ka*****@hotmail .com wrote:

What is the safest way to make an argv[] comparison? The code below
works.

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
string test;

if(argc>1)
test = argv[1];

if(test=="NKDT" )
cout << "\nComparis on is true. Have program do something.\n";
else
cout << "\nComparis on is false. Have program do something else.\n";

return 0;
}

Use a command line parser like the one in CommmonC++ :-)

#include <cc++/common.h>

ost::CommandOpt ionArg NKDT_Option(
"NKDT", "p", "--NKDT is for super stuff"
);

ost::CommandOpt ionNoArg helparg(
"help", "?", "Print help usage"
);

int main( int argc, char ** argv )
{

CommandOptionPa rse * args = ost::makeComman dOptionParse(
argc, argv,
"This command is so special !"
);

if ( helparg.numSet ) {
cerr << args->printUsage() ;
::exit(0);
}

if ( NKDT_Option.num Set )
{
cout << "\nHave program do something.\n";
return result;
} else {
cout << "\nHave program do something else.\n";
return result;
}
}

.....

The nice thing about this is that anywhere in your code, you can add
ost::CommandOpt ionXXX options and they're picked up automatically. So
main does not get complicated with every possible option. The command
option parser automatically pulls together all the parameters to create
a usage.

It's a little outdated in that it was written before std::string was
working properly on most compilers so it use C style stings everywhere.

[dave_mikesell]

On May 21, 4:28 pm, "Alf P. Steinbach" <[e-mail] rote:

getting rid of the local variable 'test' and also the 'return 0' which
is implied (it's the default) in 'main', and just to make it extra
concise I also removed that darned 'else' which otherwise would use up a
very expensive line, and the keyword 'if' which is so much to read.

The OP's example was nothing like that. Conciseness does not
necessarily lead to obfuscation, your strawman notwithstanding .

I simply don't understand why so many programmers think conciseness is a
goal.

Nor I why so many tend to overcomplicate simple solutions to simple
problems.

They just end up not understanding their own code.

Same thing happens with over-engineered code.

[Alf P. Steinbach]

* da***********@f astmail.fm:

On May 21, 4:28 pm, "Alf P. Steinbach" <[e-mail] rote:

>getting rid of the local variable 'test' and also the 'return 0' which
is implied (it's the default) in 'main', and just to make it extra
concise I also removed that darned 'else' which otherwise would use up a
very expensive line, and the keyword 'if' which is so much to read.

The OP's example was nothing like that. Conciseness does not
necessarily lead to obfuscation, your strawman notwithstanding .

>I simply don't understand why so many programmers think conciseness is a
goal.

Nor I why so many tend to overcomplicate simple solutions to simple
problems.

It is a "standard" solution. I think you'll find it somewhere at the
beginning of Accelerated C++. Although I don't have that book.

If you have questions about it I'll be happy to answer them.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Lionel B]

On Mon, 21 May 2007 20:39:14 +0200, Alf P. Steinbach wrote:

* ka*****@hotmail .com:

>What is the safest way to make an argv[] comparison? The code below
works.

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
string test;

if(argc>1)
test = argv[1];

if(test=="NKDT" )
cout << "\nComparis on is true. Have program do something.

\n";

> else
cout << "\nComparis on is false. Have program do something

else.\n";

>>
return 0;
}

Do the following:

[snip]

You appear to assume that an exception should be thrown if the command
line does not have a particular form. I see no such requirement expressed
by the OP who does not, in fact, suggest that the "false" comparison is
in any way "exceptiona l".

--
Lionel B

[Gianni Mariani]

da***********@f astmail.fm wrote:

On May 21, 4:28 pm, "Alf P. Steinbach" <[e-mail] rote:

>getting rid of the local variable 'test' and also the 'return 0' which
is implied (it's the default) in 'main', and just to make it extra
concise I also removed that darned 'else' which otherwise would use up a
very expensive line, and the keyword 'if' which is so much to read.

The OP's example was nothing like that. Conciseness does not
necessarily lead to obfuscation, your strawman notwithstanding .

>I simply don't understand why so many programmers think conciseness is a
goal.

Nor I why so many tend to overcomplicate simple solutions to simple
problems.

>They just end up not understanding their own code.

Same thing happens with over-engineered code.

std::vector is part of the standard.
std::string is part of the standard.

What about these is complex ?

There exists a minimum complexity. employing char * is usually bad news
and is prone to far more subtle complexity that is exemplified by the
OP's question.

Alf's code does more like what you would expect.