If I declare a char array of say 10 chars like so...
char letters[10];
am I creating a set of memory locations that are represented as chars fr
Seems like you are confused with arrays and strings.
When you declare
char letters[10] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
then it reserves only 10 contiguous bytes in a memory location.
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 //memory addresses. I assumed it is to be starting from 2000 for simplification.
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| | | | | | | | | | |
| '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |
| | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
In C indexing starts from 0
. You can access your allocated memory location from letters[0]
to letters[9]
. Accessing the location letters[10]
will invoke undefined behavior. But when you declare like this
char *letters = "0123456789";
or
char letters[11] = "0123456789";
then there are 11 bytes of space are allocated in memory; 10 for 0123456789
and one for \0
(NUL character).
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 //memory addresses. I assumed it is to be starting from 2000 for simplification.
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-------+
| | | | | | | | | | | |
| '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '\0' |
| | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-------+
^
| NUL character
Take another example
#include <stdio.h>
int main(){
char arr[11];
scanf("%s", arr);
printf("%s", arr);
return 0;
}
Input:
asdf
Output:
asdf
Now have a look at memory location
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-------+
| | | | | | | | | | | |
| 'a' | 's' | 'd' | 'f' |'\0' | | | | | | |
| | | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-------+
am I creating a set of memory locations that are represented as chars from index 0-9
Yes
then the 10th index is the null byte?
No.
You reserved space for exactly 10 char
s. Nothing else. Nothing will automatically set the last byte to zero, or act as if it were. There is no 11th char that could hold a zero, you only have 10.
If you're going to use that with string functions, it's your duty as the programmer to make sure that your string is null-terminated. (And here that means it can hold at most 9 significant characters.)
Some common examples with initialization:
// 10 chars exactly, not initialized - you have to take care of everything
char arr1[10];
// 10 chars exactly, all initialized - last 7 to zero - ok "C string"
char arr2[10] = { 'a', 'b', 'c' };
// three chars exactly, initialized to a, b and c - not a "C string"
char arr3[] = { 'a', 'b', 'c' };
// four chars exactly, initizalized to a, b, c and zero - ok "C string"
char arr4[] = "abc";
And throughout your programming in [Turbo(C++), try to use F7, or F8 and Alt+F4, you can see what's happening inside that will be much useful for a beginner who having doubts like this
When ever you declaring a variable a seperate memory location will be alloted to that variable. In case of array variable like
char letters[10];
Ten memory space will get alloted to letters variable.
And the size of memory allocation will get vary for different datatype(i.e. int,char,float...).
Again in your case: if your want to store a name like "csstudent" in array you have declare an array size of "ten" even "csstudent" size is "nine", because the last index is to store "\0" character indicates the end of the string
//1000,1001 are memory space alloted,may will vary in you system
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+
| | | | | | | | | | |
| 'c' | 's' | 's' | 't' | 'u' | 'd' | 'e' | 'n' | 't' | '\0' |
| | | | | | | | | | |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+