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

[Juha Nieminen]

Alf P. Steinbach wrote:

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

Why such a complicated solution to such a simple problem? How about
simply:

int main(int argc, char* argv[])
{
std::vector<std ::stringcmdLine (argv, argv+argc);

if(cmdLine.size () 1 && cmdLine[1] == "NKDT")
{
// Do something
}
else
{
// Do something else
}
}

[dave_mikesell]

On May 22, 7:57 am, Gianni Mariani <gi3nos...@mari ani.wswrote:

dave_mikes...@f astmail.fm wrote:

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.

Not sure what you mean here - the OP's solution creates a std::string
from argv[1]. If he only cares about argv[1], his solution seemed
fine to me re: parsing the command line.

[dave_mikesell]

On May 22, 7:57 am, Gianni Mariani <gi3nos...@mari ani.wswrote:

dave_mikes...@f astmail.fm wrote:

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.

Not sure what you mean here - the OP's solution creates a std::string
from argv[1]. If he only cares about argv[1], his solution seemed
fine to me re: parsing the command line.

[Alf P. Steinbach]

* Juha Nieminen:

Alf P. Steinbach wrote:

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

Why such a complicated solution to such a simple problem? How about
simply:

int main(int argc, char* argv[])
{
std::vector<std ::stringcmdLine (argv, argv+argc);

if(cmdLine.size () 1 && cmdLine[1] == "NKDT")
{
// Do something
}
else
{
// Do something else
}
}

Yours is not reusable without changes. Note that the code you put in
'main' is the code in 'cppMain' (and all code that is program-specific,
i.e. that has to be written), except that 'cppMain' is safer because it
doesn't give access to the C-style arguments and because it can safely
throw exceptions. Always think about reusing code instead of inventing
the wheel over and over with just slight details different.

--
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?

[Alf P. Steinbach]

* 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".

No, using an exception is just the simple and safe way to do things in
that context.

On the other hand, I do assume that any actual program will need to deal
with exceptions; otherwise you're using C++ as just a better C.

There are more options for that than just the code shown, but if you're
going to write a little toy program it's good boilerplate 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?

[dave_mikesell]

On May 22, 7:57 am, Gianni Mariani <gi3nos...@mari ani.wswrote:

dave_mikes...@f astmail.fm wrote:

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.

Not sure what you mean here - the OP's solution creates a std::string
from argv[1]. If he only cares about argv[1], his solution seemed
fine to me re: parsing the command line.

[Lionel B]

On Tue, 22 May 2007 17:04:34 +0200, Alf P. Steinbach wrote:

* 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".

No, using an exception is just the simple and safe way to do things in
that context.

Well, it is *a* simple(ish) and safe way.

On the other hand, I do assume that any actual program will need to deal
with exceptions;

Beside the point... the fact remains that (as far as we can know) the
"false" branch in the OP's code may be perfectly "unexceptional" . In fact
his/her action for the "false" branch was "Have program do something
else". That doesn't (to me) say "throw exception".

otherwise you're using C++ as just a better C.

A perfectly honourable use for C++ ;-)

There are more options for that than just the code shown, but if you're
going to write a little toy program it's good boilerplate code.

Sure, it's a fine idiom if deployed as the OP intended, which I'm not
convinced it was.

--
Lionel B

[Alf P. Steinbach]

* Lionel B:

>
Beside the point... the fact remains that (as far as we can know) the
"false" branch in the OP's code may be perfectly "unexceptional" . In fact
his/her action for the "false" branch was "Have program do something
else". That doesn't (to me) say "throw exception".

I'm not sure that the effect of the OP's code was intentional, and the
question was how to deal with argv, not how to replicate the effect of
the original code (still I posted such replication else-thread).

Anyway, it's silly and just plain argumentative to object to getting too
generally useful code.

If you'd objected that the code was too special purpose it could have
been a valid objection.

--
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?

[Juha Nieminen]

Alf P. Steinbach wrote:

Yours is not reusable without changes.

"My" version consists basically of two (2) lines: One line which
creates the vector, and another with compares the first command-line
argument. Your requirement of "reusabilit y" for two lines of code seems
quite odd to me. It doesn't make too much sense.

As for "without changes", that's even odder. Your solution requires
exactly as many changes to be "reusable" as mine, namely changing the
string being compared.

Note that the code you put in
'main' is the code in 'cppMain' (and all code that is program-specific,
i.e. that has to be written), except that 'cppMain' is safer because it
doesn't give access to the C-style arguments and because it can safely
throw exceptions.

Do you understand the concept of over-engineering?

Always think about reusing code instead of inventing
the wheel over and over with just slight details different.

Having to write 2 lines of code is "inventing the wheel over and
over". Right.

[Alf P. Steinbach]

* Juha Nieminen:

Alf P. Steinbach wrote:

>Yours is not reusable without changes.

"My" version consists basically of two (2) lines: One line which
creates the vector, and another with compares the first command-line
argument. Your requirement of "reusabilit y" for two lines of code seems
quite odd to me. It doesn't make too much sense.

Yes, it's true, what you're saying doesn't make sense. And the reason
that what you're saying doesn't make sense, is that you have based your
reasoning on false assumptions in order to fit a preconceived senseless
conclusion. The reusability is not for two problem-specific lines of
code: it's for argument packaging, exception handling (more generally
failure handling), main return codes, and removal of access to low-level
stuff.

And that's everything except the code between the braces in 'cppMain'.

Not that your code is much inferior, since we're talking about two
extremely trivial and short programs, but it's based on reinventing the
wheel. Except if you like spaghetti and bug-fixing, the above has to
be done for any program that does anything real. Even though we're
still talking about novice programs, toy programs, small test programs.

As for "without changes", that's even odder. Your solution requires
exactly as many changes to be "reusable" as mine, namely changing the
string being compared.

That's incorrect. And the reason it's incorrect is that you envision a
specific case of reuse where your code conceivably could be reused
mostly as-is, in order to fit your preconceived incorrect conclusion.
Out of the infinitely many programs one can make you've chosen an
extremely small set parameterized by one datum, and you incorrectly call
that reusability.

> Note that the code you put in
'main' is the code in 'cppMain' (and all code that is program-specific,
i.e. that has to be written), except that 'cppMain' is safer because it
doesn't give access to the C-style arguments and because it can safely
throw exceptions.

Do you understand the concept of over-engineering?

> Always think about reusing code instead of inventing
the wheel over and over with just slight details different.

Having to write 2 lines of code is "inventing the wheel over and
over". Right.

I'm sorry, what you're writing is not meaningful.

Nobody forces you to use save work by using that little boilerplate 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?