c++ argv[1] terminate the program with return value 9009

Question

I have a small code to look whats the argv's

#include <iostream>

using namespace std;
int main(int argc, char** argv){

    cout << "===================" << endl;
    cout << "argc: " << argc << endl << endl;
    cout << "argv[0]: " << argv[0] << endl << endl;
    cout << "argv[1]: " << argv[1] << endl << endl;
    //cout << "argv[2]: " << argv[2] << endl << endl; //Program crash
    cout << "===================" << endl;

    return 0;
}

When I start the program with no parameters:

argc is 1
argv[0] is the execution path
argv[1] should be out of range and the program should crash, but the program terminates like I write return. If I check the errorlevel it is 9009
If I try to access argv[2] the program crashs as expected

(When I start the program with one parameter everything works fine)

Why it doesn't crash like argv[2] when I access argv[1]?
And for what stand errorlevel 9009?

Thanks in advance

Possible duplicate of [Accessing an array out of bounds gives no error, why?](https://stackoverflow.com/questions/1239938/accessing-an-array-out-of-bounds-gives-no-error-why) — Amadeusz, Apr 10 '18 at 07:21
C++ doesn't have bounds-checking. Indexing out of bounds leads to [*undefined behavior*](https://en.wikipedia.org/wiki/Undefined_behavior). Any speculation about behavior is useless. — Some programmer dude, Apr 10 '18 at 07:22
@Someprogrammerdude - `argv[argc]` is always null, and is not out of bounds for the array. — StoryTeller - Unslander Monica, Apr 10 '18 at 07:24
Also note that `argv[argc]` (which will be `argv[1]` in your case) is *always* a null pointer. So technically it's not really out of bounds (as noted by @StoryTeller) — Some programmer dude, Apr 10 '18 at 07:25
@SomeProgrammerDude yes I know that but why it's doesn't crash like argv[2]. — Morchul, Apr 10 '18 at 07:26
@All Thanks for your answers, and for what stand 9009 or is this defined on the OS? — Morchul, Apr 10 '18 at 07:27
@Morchul No, undefined behavior could lead to *anything* happening, from conjuring [nasal demons](http://www.catb.org/jargon/html/N/nasal-demons.html) to seemingly working or to your program exiting with an error code being *anything* (which include the value `9009`. — Some programmer dude, Apr 10 '18 at 07:37
@Morchul- Undefined behavior is formal term that means you can't use the language spec to explain what happens. Your program is essentially illegal, and you shouldn't complain if it behaves weird. 9009 probably stands for something, but it's probably not "you wrote bad C++". — StoryTeller - Unslander Monica, Apr 10 '18 at 07:37

score 7 · Accepted Answer · answered Apr 10 '18 at 07:26

It doesn't crash because argv is defined as a null terminated array. The last element is argv[argc], that always holds a null pointer. You aren't accessing out of bounds for the array.

But...

You pass a null pointer value to std::ostream's operator<< for c-strings. That is undefined in and of itself, so your program isn't exactly well behaved in this case either.

paxdiablo · Answer 2 · 2018-04-10T07:31:15.570

3

... and the program should crash.

No, no, no!

The whole point of undefined behaviour is that it's, well, undefined.

Literally anything is allowed to happen when you dereference a null pointer (which argv[argc] is required to be, and ostream::operator<< will try to dereference it) including, and this is the most insidious aspect of UB, it working as expected sometimes, or it failing with a frankly bizarre return code :-)

But, bottom line, if you break the contract with the standard, all bets are off. Don't do it.

edited Apr 10 '18 at 07:31

answered Apr 10 '18 at 07:25

paxdiablo

854,327
234
1,573
1,953

1

@Morchul: It may or it may not. It's totally up to the implementation what it returns under UB conditions. – paxdiablo Apr 10 '18 at 07:32

c++ argv[1] terminate the program with return value 9009

2 Answers2