Common mistakes that trapped me always!

[primeSo]

I did C in UNIX environment. These are some of the common mistakes that always trapped me in my work. I need help from you guys to clarify them with me.




1)

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray + i) ); 
}
 

As we know, array name ,intArray is a constant pointer, it always point to the beginning of the array i.e. &intArray[0].

Hence, this is correct. The + operator add i to intArray. This simply means: "POINT TO i th LOCATION BEYOND intArray , which is pointing to the beginning of the intArray and DEREFENCE THE POINTER". intArray remain pointing at the first element in the array.

2)

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray ++) ); 
}
 

This is wrong. The ++ operator is changing the constant pointer , intArray to pointing to the other places, in this case, the next element in the array. In addition, the first iteration of the for loop will print the second element in the array because (intArray ++) makes intArray pointed to the second element in the array and the * dereference the pointer. And when i == 4, the pointer over flow to the end of the array and error occurred here.

3)

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray + 1) ); 
}
 

I am not sure whether this is correct or wrong. In my observation, it has the same behavior as 2).

4)

char *a = "Hello";
 
*(a + 1) = 'a';
 

The above statement is correct but the result is undefined cause ANSI C doesn't prohibit us to modify a string literal accessed via a character pointer. However, we are not advice to modify string in this manner, but can we modify the character pointer? I mean can we assign another address to a and make a point to other place. If so, how about the string literal it was originally pointed to? lose reference? Is this considered a memory leak in C ?

5)

char *b ;
 
b = malloc(5 * sizeof(char));
 
b = "hello";
 

Compare with 4), i am confused. Why do we need malloc() at the first place since we can initialize a character pointer to point to a string literal? In 4), we could use "a" directly instead of malloc it , why? I have tried to assign a string to "b" WITHOUT malloc it, but encountered run time error i.e. core dump. Since we malloc b, so we cannot change the value of b ? If we changed it, we lose reference to the memory slots where it was originally pointed to, thus memory is leaking, am i correct? Provided we free b before modifying b.

4) and 5), i am not very sure what is the logic behind them.

I always trapped by these mistake and slowing down my work. : (

[oler1s]

It's not entirely clear what you are thinking, because of the confusion in your own statements. I'll comment on what I think you said.

Q1:
Referring to intArray is syntactically equivalent to referring to &intArray[0]. Hence, you can use pointer arithmetic on it. intArray + 1 gets you a pointer to the second element in the array (a pointer to intArray[1]). Not sure how dereferencing comes into the picture, but your grammar with the word "dereferenc e" didn't resolve to anything meaningful.

Q2:
Yes, what you did wouldn't work. But I thought about it for a moment and wanted to clarify. You can't do intArray++, right, because intArray can't be set to something else. But you can do:

int *p = intArray;
int c = *p++;
 

Now, where am I going with this? Because you might see code like:

void my_strcpy(char *dest, char *source)
{
    .
    .
    *dest++ = *source++;
    .
}
 

or something along those lines. And it works. Why? Because, remember that when passing something into a function, a copy is made. In this case, if you pass in an array to a function, the function has a pointer to that array. But it isn't the array variable itself. It's a local function pointer to the array you passed in.

Q3:

It's valid. intArray is not being modified. Only i is.

Q4:

The code is not correct. char *a is not the same as char a[]. a[] is an array. *a is a pointer. "Hello" is a constant string literal that a is set to point to. That means you can't modify the contents of that string. So you have a pointing to a constant string. You can't refer to part of that string and change it to something else, because you don't have an array.

If you had an array, you could always use pointer notation to modify it. But you need an array storing the string, not a string literal. Do you get the difference?

Q5:

Now that you know that Q4 is wrong, how would you get a block of memory you can modify? Either statically declare an array. Or dynamically allocate memory for it using malloc. Unfortunately, the above code is also bad. Here's why. char *b is a pointer. b = malloc(...) assigns b to a memory block that is dynamically allocated. Then b = "Hello" assigns b to another memory location that contains the literal string "Hello".

Let me be clear about this, b = "Hello" does not copy the string.

Feel free to follow up with clarifying questions.

You may want to read the C-FAQ: http://c-faq.com/index.html. I will ask you to read section 6 at the very least before posting further questions. Section 8 as well.

[primeSo]

Thank you for the site, it has cleared most of my doubt. : ) . Let me clarify again with i have understand so far.

1)

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray + i) ); 
}
 

Result of these statements: 12345.
*(intArray + i) == intArray[i], I am pretty sure with this.

2)

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray ++) ); 
}
 

Let's do some desk check.
When i = 0, print: 2
i = 1, print: 3
i = 2, print: 4
i = 3, print: 5
i = 4, print: undefined. array overflow (error)

++ ( +1) move the pointer beyond the boundary of the array. correct ?

3)

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray + 1) ); 
}
 

Result from these statements: 22222.

Conclusion:
intArray++ move intArray forward to point to the next object (POSITION OF intArray CHANGED) ) while intArray + 1 doesn't move the pointer, (intArray REMAIN THE SAME POSITION), am i correct ?

4)

char *a = "Hello";
 
*(a + 1) = 'a';
 

We shouldn't modify a CONSTANT string literal with any means. In addition,do a and "Hello" both are constant? We shouldn't modify any of them?

5)

char *b ;
 
b = malloc(5 * sizeof(char));
 
b = "hello";
 

We can't use assignment operator ( = ) when assigning string, use strcpy() instead. This is my mistake, haha.

Conclusion:
We can INITIALIZE a pointer to character with char *a = "Hello"; But this is NOT ASSIGNMENT, it simply means: a is a character pointer pointing to the beginning of a chunk of memories and the memories has no name, in this case 5 bytes + 1 null character. And both of them are CONSTANT.

Except the above mentioned situation, any other character pointer must be malloc-ed if we want them to point to a specify unnamed memory location in the machine to store some character value, ie strings.

Thank you.

[primeSo]

Array name is a constant pointer. So, how can we do pointer arithmetic on array name like intArray++ at the first place? This statement is equivalent to intArray += 1.

An array name is ``constant'' in that it cannot be assigned to

Source: http://c-faq.com/aryptr/constptr.htm

What does the "assigned" meant? We cannot change the value contained by array name, am i correct ? IT ALWAYS POINTS TO THE FIRST ELEMENT IN THE ARRAY. but how could intArray++ works at the first place? it is changing the value of intArray.

[weaknessforcats]

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray ++) );     <<<<<<<<<<<<<<
}
 

Please ask questions only about code that compiles.

[oler1s]

So on your clarifications:

Q1: Yes, that's right. I think you have the idea about pointer arithmetic vs. array indexing.

Q2: NO! You had the right idea before, and now you have it wrong. You can't change the pointer intArray itself. If you want to increment a pointer, it needs to be copy of intArray, not intArray itself.

Q3: Yes, intArray + 1 never changes as both intArray and 1 always remain the same...

Q4: Yes. You can't modify that literal. "Hello" isn't being stored in an array. All you have is a literal and a pointer to it.

I don't believe a is constant. You would have to say something like const char *a = "Hello".

I don't know whether or not even if you could, it's OK for you to point a somewhere else. I can't give you a confident answer. I would have to go through various documentation to answer with certainty.

Q5: Yes, the = sign does not copy a string. You need to manually walk through the string, copying each character by character. That's what strcpy does for you.

A char pointer is just that. You can point it to a literal, a dynamically (malloced) allocated memory block of chars, or you can set it equal to another pointer.

Char pointers test your knowledge of pointers. Fundamentally, you need to be clear on the difference between a pointer and an array.

[primeSo]

int intArray[5] = {1,2,3,4,5}, i;
 
for(i = 0; i < 5; i ++){
   printf( "%d", *(intArray ++) );     <<<<<<<<<<<<<<
}
 

Please ask questions only about code that compiles.

Hm... i am sorry. Don't get what you mean. : )

[primeSo]

Q2: NO! You had the right idea before, and now you have it wrong. You can't change the pointer intArray itself. If you want to increment a pointer, it needs to be copy of intArray, not intArray itself.

haha, i think i am almost there. thank you. I always forgotten the concept of "a copy of the actual parameter, NOT the actual parameter itself". Thank you.

Just one more point to go, let's say those statements in my example are being done in one main(), i didn't so any function calling, then intArray++ is totally wrong. My GCC compiler complainted "Wrong Type Of Argument to Increment". : )

intArray++ can only be done when i call another function to process the array. Thank you. I got it now. *( intArray ++) would not overflow the array but *( ++ intArray) would do.

10s~