CODEWITHSUNDEEP
c++c
Jatin
Jatin

Reputation: 1997

Related to strings

//SECTION I:
void main()
{
    char str[5] = "12345";  //---a)
    char str[5] = "1234";   //---b)
    cout<<"String is: "<<str<<endl;
}
Output: a) Error: Array bounds Overflow.
        b) 1234

//SECTION II:
void main()
{
    char str[5];
    cout<<"Enter String: ";
    cin>>str;
    cout<<"String is: "<<str<<endl;
}

I tried with many different input strings, and to my surprise, I got strange result:

Case I: Input String: 1234, Output: 1234 (No issue, as this is expected behavior)

Case II: Input String: 12345, Output: 12345 (NO error reported by compiler But I was expecting an Error: Array bounds Overflow.)

Case III: Input String: 123456, Output: 123456 (NO error reported by compiler But I was expecting an Error: Array bounds Overflow.)

.................................................

.................................................

Case VI: Input String: 123456789, Output: 123456789(Error: unhandeled exception. Access Violation.)

My doubt is, When I assigned more characters than its capacity in SECTION I, compiler reported ERROR: Array bounds Overflow.

But, when I am trying the same thing in SECTION II, I am not geting any errors. WHY it is so ?? Please note: I executed this on Visual Studio

Upvotes: 1

Views: 214

Answers (6)

moooeeeep
moooeeeep

Reputation: 32542

char str[5] = "12345";

This is a compiletime error. You assign a string of length 6 (mind the appended null-termination) to an array of size 5.

char str[5];
cin>>str;

This may yield a runtime error. Depending on how long the string is you enter, the buffer you provide (size 5) may be too small (again mind the null-termination).

The compiler of course can't check your user input during runtime. If you're lucky, you're notified for an access violation like this by Segmentation Faults. Truly, anything can happen.

Throwing exceptions on access violations is not mandatory. To address this, you can implement array boundary checking yourself, or alternatively (probably better) there are container classes that adapt their size as necessary (std::string):

std::string str;
cin >> str;

Upvotes: 4

Israel Unterman
Israel Unterman

Reputation: 13520

char str[5] = "12345" - in this case you didn't leave room to the null terminator. So when the application tries to print str, it goes on and on as long as a null is not encountered, eventually stepping on foridden memory and crashing.

In the `cin case, the cin operation stuffed 0 at the end of the string, so this stops the program from going too far in memory.

Hoever, from my experience, when breaking the rules with memory overrun, things go crazy, and looking for a reason why in one case it works while in other it doesn't, doesn't lead anywhere. More often than not, the same application (with a memory overrun) can work on one PC and crash on another, due to different memory states on them.

Upvotes: 2

b.buchhold
b.buchhold

Reputation: 3906

It's because in the second case, the compiler can't know. Only at runtime, there is a bug. C / C++ offer no runtime bounds checking by default, so the error is not recognized but "breaks" your program. However, this breaking doesn't have to show up immediately but while str points to a place in memory with only a fixed number of bytes reserved, you just write more bytes anyways.

Your program's behavior will be undefined. Usually, and also in your particular case, it may continue working and you'll have overwritten some other component's memeory. Once you write so much to access forbidden memory (or free the same memory twice), your program crashes.

Upvotes: 2

URaoul
URaoul

Reputation: 553

because compiler does static check. In your section II, size is unknown in advance. It depends on your input length.

May i suggest you to use STL string ?

Upvotes: 1

Naveen
Naveen

Reputation: 73503

What you are seeing is an undefined behavior. You are writing array out of bounds, anything might happen in that case ( (including seeing the output you expect).

Upvotes: 4

iammilind
iammilind

Reputation: 70096

I tried with many different input strings, and to my surprise, I got strange result:

This phenomena is called Undefined behavior (UB).

As soon as you enter more characters than a char array can hold, you invite UB.
Sometime, it may work, it may not work sometime, it may crash. In short, there is no definite pattern.

[side note: If a compiler allows void main() to get compiled then it's not standard compliant.]

Upvotes: 3

Related Questions