Little warning on linked lists example

Hi there.

Following my latest thread about queues, someone suggested me something to my code that I decided to also implement it on my linked-lists example but it gives me a warning. Though, it compiles and works...

Here's the code:

Code:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX 10

typedef struct sList {
	int elem;
	struct sList *next;
} List;

List* insertList(List *l, int elem) {
	if(!l) {
		List *x = (List*)malloc(sizeof(List));
		
		x->elem = elem;
		x->next = NULL;
		
		return x;
	} else {
		l->next = insertList(l->next, elem);
		
		return l;
	}
}

void printList(const List *l) {
	List *ptr = l; // warning: initialization discards qualifiers from pointer target type
	
	do {
		printf("%d", ptr->elem);
		ptr = ptr->next;
		
		if(ptr) printf(" -> ");
	} while(ptr);
}

int main() {
	List *l = NULL;
	int i, num;
	
	srand((unsigned)time(NULL));
	
	printf("RANDOM: ");
	
	for(i = 0; i < MAX; i++) {
		num = rand() % 100 + 1;
		printf("%d ", num);

		l = insertList(l, num);
	}

	printf("\n\nLIST: ");
	printList(l);
	
	return 0;
}

There's only one line with a comment which is the line that produces the warning and the comment itself is the warning.

What does it mean and how can I get rid of it?

l is const while ptr is declared as non-const.
You should make ptr const: const List* ptr = l;
Const is there to catch mistakes; you shouldn't do away with it.

But in the queues thread where you suggested me to do that, I didn't had const to ptr and it didn't produce any warning. That's why I'm asking...

Does the function printList require a non-const pointer? No, because it does not modify any data; thus your const is correct and ptr should be const too!
I think you may have gotten this a little backwards.
If the function printList DID modify the memory at the pointer, then it shouldn't take a const pointer in the first place!

You are confusing me...

I just add the const like you said before just to prevent the compiler from compiling if in that function the memory was being modified and I didn't want that. And in the queues example, the memory was being modified so I add the const to the function argument but I didn't add it to the ptr and it worked without any warning.

The printList function is not modifying the memory, so, should I just remove the const?

OK, so let me repeat:
- Const will help you find mistakes.
- If const is applies to a pointer, the compiler will spew an error if you try to modify the memory pointed to by the pointer.
- If a function is not supposed to modify the pointer pointed to by a pointer, then that pointer should be const.

So think before you design something... is this function supposed to modify memory pointed to by the pointer? If the answer is no, then it should take a const pointer. But you must keep the const intact in the whole function.
If you do

Code:

void foo(const int* p)
{
	*p = 70;
}

void foo2(const int* p)
{
	int* n = p;
	*n = 70;
}

First example won't work because p is const. Second will work because you're doing away with the const which is obviously wrong.
The solution is to make n const too --> const int* n = p;
If a function takes a const pointer, then you must declare every other pointer const that you're assigning that address from the const pointer.

Your function printList should take a const pointer because it's not modifying any memory. Similarly, your local variable ptr must also be const, otherwise it's the same result as if the function wasn't taking a const variable at all!

But why on my queues example I only have to add const the the function argument and not to the local variable ptr as in the printList example?

Both functions are not modifying any memory, so, both should take a const pointer like you said and similarly, like you also said, the local varible ptr must also be const. I think this applies to both functions (printQueue and printList) because both are not modifying any memory.

So, you are saying that also on the printQueue function I should add const to the function argument and local variable ptr?

First example won't work because p is const. Second will work because you're doing away with the const which is obviously wrong.

I am less familiar with const in C, but I believe both will not work. const int* p means that what p points to is const, not p itself. int* const p on the other hand, means that p is const.

Originally Posted by laserlight

I am less familiar with const in C, but I believe both will not work. const int* p means that what p points to is const, not p itself. int* const p on the other hand, means that p is const.

Oh, the second one works alright.
The first one doesn't. You can check with your c compiler

Originally Posted by Nazgulled

But why on my queues example I only have to add const the the function argument and not to the local variable ptr as in the printList example?

I can't remember from the top of my head, but here's the thing - as seen from my second example, if you don't add const to your local pointer and assign the address from the const pointer, then you're effectively removing the const. So then what's the use of const in the first place? Remember that the function SHOULD take a const pointer because it doesn't modify the memory it holds.
So in that case, ptr must be const.
However, if you are assigning memory to ptr from a source that is NOT const (in your case, that would be anything but l), then it can or can not be const. If you promise never to change the data it points to after assigning it, then yes, it should be const too, to be 100% correct.

Both functions are not modifying any memory, so, both should take a const pointer like you said and similarly, like you also said, the local varible ptr must also be const. I think this applies to both functions (printQueue and printList) because both are not modifying any memory.

Exactly.

So, you are saying that also on the printQueue function I should add const to the function argument and local variable ptr?

If they do not modify memory, then yes.

Oh, the second one works alright.

Ah, so gcc 3.4.5 only complains with a warning, though g++ 3.4.5 reports an error. I still do not recommend talking about const pointers when you mean pointers to const. Naming iterators to const const_iterator in the C++ standard library was a mistake, no need to propagate it to C as well.

Hmmm. "ptr is const" and "l is a pointer to const".
Is that better definition?