Unusual behaviour of strings

Question

#include<stdio.h>
#include<iostream>
#include<cstring>
using namespace std;
int main(void)
{
    char a[10]="Rosewater";
    char b[3];

    int i=0;
    for(i=0;i<5;i++)
    {
        b[i]=a[i]; //1. does not throw an error
    }
    printf("%s\n%s\n",a,b);
}

Output:

ewsewater        // value of a also changed

Rosewsewater      // unclear output

Answer 1

//1. does not throw an error

In C and in C++ there is no bounds check because it is simply exposing raw memory.

That what is defined as Undefined Behaviour. That means (in very short) that the standard does not specify what will happen in your program, anything could happen when an instruction produces an undefined behaviour.

My suggest if you're using C++ (which is a different language from C) is to use std::vector class. Here References.

Note that std::vector produces an undefined behaviour when you try to access to a index out of bounds. With the method at, instead, an exception will throw in that case.

#include <vector>

int main(int argc, char* argv[]) {
  std::vector<char> a = {'a', 'b', 'c'};
  a.at(5);  // it will throw an exception
  return 0;
}

Moreover, if you have to manage strings the most convenient class is std::string.

Answer 2

Accessing memory beyond the allocated chunk is an Undefined behavior.

for(i=0;i<5;i++)
{
    b[i]=a[i]; //1. does not throw an error
}

In this loop you will end up assigning b[3]=a[3] and b[4]=a[4];

b[3] and b[4] are unallocated chunks of memory. So accessing them is an undefined behavior.

There can be unpredictable results due to undefined behavior.

According to standard:

Possible undefined behavior ranges from ignoring the situation completely with unpredictable results, to behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message).

Edit: For your doubt about segmentation fault:

Segmentation fault is a specific kind of error caused by accessing memory that “does not belong to you". But the reverse is not true i.e you can not say that you'll get a segmentation fault whenever you access an un-allocated memory.

There are systems out there that operate without memory protection, thus you cannot tell whether a piece of memory actually "belongs to you", and thus don't know whether segmentation fault will occur or not, only undefined behavior is assured.

Answer 3

char b[3]; // [X] [X] [NULL_CHAR] at this point

  int i=0;
  for(i=0;i<5;i++)
  {
     b[i]=a[i]; //1. does not throw an error
  }

so basically, your'e corrupting memory when i=3/4/5. this is undefined behaviour. if your program don't own that memory - it will be a seg. fault. but its only a matter of luck, this program behaviour is unexpected.