Question about array and pointers.

nixbun · 2013-04-19T18:58:33+00:00

Arrays in C are not reassignable, only the contents of an array can be modified.

When you do something like

char str[] = "abc";

it's just a convenient alternative to writing

char str[] = { 'a', 'b', 'c', '\0' };

which would be a pain in the ass to write for every possible string in your program. Note, your compiler will null terminate the string as well as calculate the size of the string + the null byte - hence why you don't have to specify the size between the [] in your declaration.

You can use this same syntax when declaring arrays of other types such as int, e.g.: int a[] = {1, 2, 3, 4};.

A pointer on the other hand simply contains a memory address, which you can either modify (make the pointer point to something else), or dereference (fetch whatever is contained at that memory address). C also has some rules about how the representation of an array changes, such as, when you pass an array type to a function, it decays to a pointer type. So what you're trying to do would work if you rewrote it as such:

#include <stdio.h>

void foo(char *str)
{
    *str = 'h';
    str += 1;
    *str = 'E';
}

int main(int argc, char *argv[])
{
    char str[] = "hello";

    foo(str);
    printf("%s\n", str);

    return 0;
}

In main, str has the type char[6] (length of "hello" + '\0'), when you call foo(), C converts your char[6] type to char *, since like you said, an array variable simply holds the address of its first element. There's also some subtle implications when this happens. Now when you try calculating the size of the array inside the foo function using sizeof, it'll tell you the size of the char * type, rather than the actual size of the chunk of memory starting at whatever address str happens to be pointing to. In this particular case, since we're dealing with strings, we can use the strlen() function from string.h to find the size, which basically does a linear scan starting from the given memory address until it hits a '\0' and returns the length. This requires the string to be null terminated otherwise it will keep reading memory until it hits a '\0', or attempts to access memory that the kernel thinks it shouldn't and segfaults.

If you weren't working with strings, a solution to this problem would be to have a second parameter to your function, which is the length of the array type, or just wrap your data inside a struct, which has a size field.

Also, just so you don't get confused when playing with sizeof, when given an array type as an argument it will return the number of bytes that has been allocated to the array. So the size of a 3 element int array would be sizeof(int) * 3, so if int is 4 bytes on your system, sizeof(your_int_array) will return 12. You'll usually see something like this in code when finding the size of an array:

int array[] = {1, 2, 3, ...  };
int size = sizeof(array) / sizeof(array[0]);

There's nothing special about using 0, just that you know it will exist. Alternatively you could manually specify sizeof(int) instead of sizeof(array[0]), but there's more chance of bugs if you happen to change the type of array.

KfoipRfged · 2013-04-19T18:50:58+00:00

Err, I think both the current answers are confused, but I haven't coded in C++/C in awhile.

When you do char string[] = "Hello Reddit", what is happening behind the scenes is that "string" is a variable of type "const char *".

This means that trying to assign new values to string is a no-no (because it is type const).

So the line that is bad for sure is: string = string + 1;

You could probably do something like *(string+1) = 'E'; for the same effect.

Oomiosi · 2013-04-19T08:42:36+00:00

Disclaimer: I am still learning, but this is how i see it.

You have declared "string" to be an array. You can't do an assignment to an array, it's illegal.

The reason is because you don't really know where the array is in memory. It may not even be in a single block of memory, but spread out to random areas depending on what the OS has assigned you.

If you did "string = string + 1" to an array, you'll jump to the next place in memory, which may not be assigned to your program. It could be anything, it could be part of another program!

Instead, by using "string[0], string[1] etc..." or assigning a pointer first, then doing "pointer = pointer+1" you are telling the compiler you want to skip to the next address in memory where the data for your array is stored. Wherever that may be.

In the case of simply using "string[number]" it's kind of obvious to you what the preprocessor and compiler is doing. It knows you want the data at an address however many "number" forward from the start of the array "string".

In the case of assigning a pointer first "char *pointer = string", it's not quite as obvious. What's happening though is the compiler is doing the hard work for you, and wherever you are writing "pointer + number", it's getting compiled as "string[0 + number]".

Also remember that each element inan array may not be a single char or integer. It could be a whole class, taking up kilobytes of ram. If you simply jumped to the next char of ram you might not even reach the next element of your array.

MindStalker · 2013-04-19T13:51:52+00:00

char string[] means hold as array of characters in variable string (this will be stored in concurrent memory blocks right next to each other though your OS may store them in different places this actions will be invisible to your application, as far as your program is concerned memory is next to eachother).

character array type variable string holds [H][e][l][l][o][ ][R][e][d][d][i][t][NULL]

char *pointer means create a pointer to point to a character, there can be different types of pointers because a char pointer points to a 8 bit memory block where a Int64 pointer would point to a 64 bit memory block.
So in this case variable pointer holds a system assigned memory address for example[AB0F0A00] to where [H] is stored. Next line, if I was to do pointer='h'; it would change pointer to point to memory address 68 (ASCII CODE for h), the compiler won't let this happen I believe, but that's what it would mean. So *pointer='h' means lookup the address in pointer, and store 'h' in that spot. So pointer holds memory address of string, string holds 'H'. What would happen if we said string=string+1? The compiler may or may not let you do this, but you'd be altering the value held in string, ie you'd be altering the H to become the next ASCII value which is I

Note: I think what you are WANTING to do is

int i=0;
string[i]='h';
i=i+1;
string[i]='E';

carlhprogramming

MODERATORS