Comments on: Pointers, arrays, and string literals

By: hitechnical

hitechnical — Mon, 05 Oct 2009 12:16:48 +0000

It will be great if you elaborate your article with pointer declarations like this,

char *string = { “This is a string” }

I was not sure how to pass-by-reference a string like this and also the const-correctness issue.

By: Jeff

Jeff — Tue, 28 Jul 2009 16:29:42 +0000

You too, Ian. Have you looked at the safe c library? It contains some very well-written string functions. The code is extremely clean and readable, too.

By: Ian

Ian — Mon, 27 Jul 2009 04:13:24 +0000

It can be even more insidious than that, in fact. There are really 4 possibilities, and 3 look quite similar.


        char a[] = "This is a test";    // immutable pointer to mutable memory
        char *b = "this is another test";  // mutable pointer to immutable memory
        char *c = malloc(256); // mutable pointer, mutable memory
        const char *const d = "this is the fourth test";  // immutable pointer, immutable memory  -- really, really constant
        strcpy(c, "this is yet another test");

        a[2] = 'I';    // compiles, works
        b[2] = 'I';    // compiles, Fails!
        c[2] = 'I';    // compiles, works
        d[2] = 'I';    // will not compile
        
        a = b;  // compile error
        c = a;  // Legal, works
        d = c;  // compile error

This also touches on the fact that saying const char *foo gives you a constant value. You can't change the thing it points to, but the pointer itself is fair game. Strings in C are a minefield of trickiness. By the way, it was nice meeting you at PyOhio this weekend.

By: Jeff

Jeff — Fri, 26 Jun 2009 11:33:07 +0000

Often, it’s because a language is developed organically rather than top-down. That is especially true for lisp, which was conceived of more than half a century ago when the available alternatives were fortran, assembly, and punched cards. CAR and CDR are much simpler than their equivalent forms in assembly. From http://www.statemaster.com/encyclopedia/Car-and-cdr:

The 704 assembler macro for cdr was
LXD JLOC,4
CLA 0,4
PDX 0,4
PXD 0,4[1]

By: Andrew Pennebaker

Andrew Pennebaker — Thu, 25 Jun 2009 20:18:08 +0000

Oh wow. I know about these kinds of things generally, which makes reading/writing C easier. But I thought *char vs char[] was simply a syntax nicety. Thanks for clearing that up. Explicit pointer syntax is stupid. Do language developers ever think about these kinds of easily solved syntax problems? I think it’s disastrous that Lisp uses CAR/CDR instead of FIRST/REST. These are issues that newbies discover every time they are introduced to a language. How come engineers with PhDs can’t imagine them?

By: Sara

Sara — Wed, 24 Jun 2009 03:14:46 +0000

Pretty nice post. I just came across your site and wanted to say
that I have really enjoyed reading your blog posts. Any way
I’ll be subscribing to your feed and I hope you write again soon!

By: Jeff

Jeff — Mon, 22 Jun 2009 12:33:45 +0000

I’ve updated the function, putting the null terminator test at the beginning of the loop.

By: Tordek

Tordek — Fri, 19 Jun 2009 21:33:33 +0000

There’s another subtle bug on strtoupper:

int a[] = “”;
a = strtoupper(a);

will break. The pointer is not null (so, it passes the null check), but then inside the do, the first () char gets toupper’ed, which is not a problem. On the while check, the pointer is advanced firs, and checked second, so the (only) of the string isn’t seen.

A correct implementation would be as Michael wrote, checking the content first, and stepping forward last.

Also, a better (IMHO) way to handle errors is to return as early as possible, like so:

char* strtoupper(char *str)
{

if(NULL == str) {
return NULL;
}

char *start = str;

while (*str) {
*str = toupper(*str);

str++;
}

return start;
}

(I’ve separated the assigning and the increasing, even though it’s not necessary, to make it an itty bit cleaner.)

By: Jeff

Jeff — Fri, 19 Jun 2009 14:35:22 +0000

Thanks. I added a check for null pointers.

By: Michael

Michael — Fri, 19 Jun 2009 14:15:24 +0000

You have a bug in strtoupper() — it will crash if NULL is passed in. i.e. strtoupper(NULL);

This is a more type safe version:
void strtoupper(char *str)
{
if( str )
while (*str)
{
*str++ = toupper(*str);
}
}