Deep C

Deep C (and C++)
by Olve Maudal and Jon Jagger

http://www.noaanews.noaa.gov/stories2005/images/rov-hercules-titanic.jpg

Programming is hard. Programming correct C and C++ is particularly hard. Indeed, both in C
and certainly in C++, it is uncommon to see a screenful containing only well defined and
conforming code. Why do professional programmers write code like this? Because most
programmers do not have a deep understanding of the language they are using. While they
sometimes know that certain things are undefined or unspecified, they often do not know why
it is so. In these slides we will study small code snippets in C and C++, and use them to discuss
the fundamental building blocks, limitations and underlying design philosophies of these
wonderful but dangerous programming languages.

October 2011

Suppose you are about to interview a candidate for a position as
C programmer for various embedded platforms. As part of the
interview you might want to check whether the candidate has a
deep understanding of the programming language or not... here
is a great code snippet to get the conversation started:


int main()
{
int a = 42;
printf(“%dn”, a);
}


int main()
{
int a = 42;
}

What will happen if you try to
compile, link and run this program?

What will happen if you try to compile, link and run this program?
int main()
{
int a = 42;
}

int main()
{
int a = 42;
}

One candidate might say:

int main()
{
int a = 42;
}

You must #include <stdio.h>, add
One candidate might say: a return 0 and then it will compile and
link. When executed it will print the value
42 on the screen.

int main()
{
int a = 42;
}

You must #include <stdio.h>, add
One candidate might say: a return 0 and then it will compile and
link. When executed it will print the value
42 on the screen.

and there is nothing
wrong with that answer...

int main()
{
int a = 42;
}

But another candidate might use this as an opportunity to start
demonstrating a deeper understanding. She might say things like:

int main()
{
int a = 42;
}

But another candidate might use this as an opportunity to start
demonstrating a deeper understanding. She might say things like:

You probably want to #include <stdio.h>
which has an explicit declaration of printf(). The
program will compile, link and run, and it will write the
number 42 followed by a newline to the standard
output stream.

int main()
{
int a = 42;
}

and then she elaborates
a bit by saying:

int main()
{
int a = 42;
}

and then she elaborates A C++ compiler will refuse to compile this code as the
language requires explicit declaration of all functions.
a bit by saying:

int main()
{
int a = 42;
}

a bit by saying:
However a proper C compiler will create an implicit
declaration for the function printf(), compile this
code into an object ﬁle.

int main()
{
int a = 42;
}

a bit by saying:

And when linked with a standard library, it will ﬁnd a
deﬁnition of printf()that accidentally will match the
implicit declaration.

int main()
{
int a = 42;
}

a bit by saying:


So the program above will actually compile, link and run.

int main()
{
int a = 42;
}

a bit by saying:


So the program above will actually compile, link and run.

You might get a warning though.

int main()
{
int a = 42;
}

and while she is on the roll, she might continue with:

int main()
{
int a = 42;
}

If this is C99, the exit value is deﬁned to indicate
success to the runtime environment, just like in
C++98, but for older versions of C, like ANSI C
and K&R, the exit value from this program will
be some undeﬁned garbage value.

int main()
{
int a = 42;
}

If this is C99, the exit value is deﬁned to indicate
success to the runtime environment, just like in
C++98, but for older versions of C, like ANSI C
and K&R, the exit value from this program will
be some undeﬁned garbage value.

But since return values are often passed in a
register I would not be surprised if the garbage
value happens to be 3... since printf() will
return 3, the number of characters written to
standard out.

int main()
{
int a = 42;
}


And talking about C standards... if you want to show
that you care about C programming, you should use
int main(void) as your entry point - since the
standard says so.

Using void to indicate no parameters is essential for
declarations in C, eg a declaration ‘int f();’, says
there is a function f that takes any number of
arguments. While you probably meant to say
‘int f(void);’. Being explicit by using void also
for function deﬁnitions does not hurt.

int main(void)
{
int a = 42;
}

int main(void)
{
int a = 42;
}

and to really show off...

Also, if you allow me to be a bit
pedantic... the program is not really
compliant, as the standard says that the
source code must end with a newline.

int main(void)
{
int a = 42;
}

ah, remember to include an explicit
declaration of printf() as well


int main(void)
{
int a = 42;
}

#include <stdio.h>

int main(void)
{
int a = 42;
}

#include <stdio.h>

int main(void)
{
int a = 42;
}

now, this is a darn cute little C program! Isn’t it?

#include <stdio.h>

int main(void)
{
int a = 42;
}

and here is what I get when compiling, linking and running the
above program on my machine:

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc -std=c89 -c foo.c

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc foo.o

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc foo.o
$ ./a.out

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc foo.o
$ ./a.out
42

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc foo.o
$ ./a.out
42
$ echo $?

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc foo.o
$ ./a.out
42
$ echo $?
3

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc -std=c89 -c foo.c $ cc -std=c99 -c foo.c
$ cc foo.o
$ ./a.out
42
$ echo $?
3

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ cc foo.o $ cc foo.o
$ ./a.out
42
$ echo $?
3

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ ./a.out $ ./a.out
42
$ echo $?
3

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ ./a.out $ ./a.out
42 42
$ echo $?
3

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ ./a.out $ ./a.out
42 42
$ echo $? $ echo $?
3

#include <stdio.h>

int main(void)
{
int a = 42;
}


$ ./a.out $ ./a.out
42 42
$ echo $? $ echo $?
3 0

Is there any difference between these two candidates?

Is there any difference between these two candidates?

Not much, yet, but I really like her answers so far.

Now suppose they are not really candidates. Perhaps they
are stereotypes for engineers working in your organization?

Now suppose they are not really candidates. Perhaps they
are stereotypes for engineers working in your organization?

Would it be useful if most of your colleagues have a deep
understanding of the programming language they are using?

Let’s ﬁnd out how deep their knowledge of C and C++ is...

#include <stdio.h>

void foo(void)
{
int a = 3;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h> it will print 4, then 4, then 4

void foo(void)
{
int a = 3;
++a;
printf("%dn", a);
}

int main(void)
{
foo(); it will print 4, then 4, then 4
foo();
foo();
}

#include <stdio.h>

void foo(void)
{
static int a = 3;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h> it will print 4, then 5, then 6

void foo(void)
{
static int a = 3;
++a;
printf("%dn", a);
}

int main(void)
{
foo(); it will print 4, then 5, then 6
foo();
foo();
}

#include <stdio.h>

void foo(void)
{
static int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h> eh, is it undeﬁned? do you get garbage values?

void foo(void)
{
static int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}


void foo(void)
No, you get 1, then 2, then 3
{
static int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}


void foo(void)
{
static int a;
++a; ok, I see... why?
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}


void foo(void)
{
static int a;
printf("%dn", a);
} because static variables are set to 0

int main(void)
{
foo();
foo();
foo();
}


void foo(void)
{
static int a;
printf("%dn", a);
} because static variables are set to 0

int main(void)
{
foo();
foo(); the standard says that static variables are initialized
foo(); to 0, so this should print 1, then 2, then 3
}

#include <stdio.h>

void foo(void)
{
int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

Now you get 1, then 1, then 1
#include <stdio.h>

void foo(void)
{
int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
Ehm, why do you think that will happen?
void foo(void)
{
int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
void foo(void)
{ Because you said they where initialized to 0
int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
void foo(void)
int a;
++a; But this is not a static variable
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
void foo(void)
int a;
printf("%dn", a);
} ah, then you get three garbage values

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
void foo(void)
int a;
printf("%dn", a);

int main(void) the value of a will be undeﬁnded, so in theory you
{ get three garbage values. In practice however, since
foo(); auto variables are often allocated on an execution
foo(); stack, a might get the same memory location each
foo(); time and you might get three consecutive values... if
} you compile without optimization.

#include <stdio.h>
void foo(void)
int a;
printf("%dn", a);


on my machine I actually get, 1, then 2, then 3

#include <stdio.h>
void foo(void)
int a;
printf("%dn", a);


on my machine I actually get, 1, then 2, then 3

I am not surprised... if you compile in debug mode the
runtime might try to be helpful and memset your
stack memory to 0

#include <stdio.h> Why do you think static variables are set to 0,
while auto variables are not initialized?
void foo(void)
{
int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

void foo(void)
{
int a; eh?
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

void foo(void)
{
int a; eh?
++a;
printf("%dn", a);
} The cost of setting auto variables to 0 would
increase the cost of function calls. C has a very
int main(void) strong focus on execution speed.
{
foo();
foo();
foo();
}

void foo(void)
{
int a; eh?
++a;
printf("%dn", a);
{
foo();
foo(); Memsetting the global data segment to 0
foo(); however, is a one time cost that happens at
} start up, and that might be the reason why it is
so in C.

void foo(void)
{
int a; eh?
++a;
printf("%dn", a);
{
foo();
foo(); Memsetting the global data segment to 0
foo(); however, is a one time cost that happens at
} start up, and that might be the reason why it is
so in C.

And to be precise, in C++ however, static
variables are not set to 0, they are set to their
default values... which for native types means 0.

#include <stdio.h>

static int a;

void foo(void)
{
int a;
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>

static int a;

void foo(void)
{

++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>

static int a;

void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

1, 2, 3
#include <stdio.h>

static int a;

void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

1, 2, 3
#include <stdio.h>
ok, why?
static int a;

void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

1, 2, 3
#include <stdio.h>
ok, why?
static int a;
because a is static, and therefore initialized to 0
void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

1, 2, 3
#include <stdio.h>
ok, why?
static int a;
void foo(void)
{ I agree...
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

1, 2, 3
#include <stdio.h>
ok, why?
static int a;
void foo(void)
{ I agree...
++a;
printf("%dn", a); cool!
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>

int a;

void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

garbage, garbage, garbage
#include <stdio.h>

int a;

void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
why do you think that?
int a;

void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
int a;
oh, is it still initialized to 0?
void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
int a;
void foo(void)
{ yes
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
int a;
void foo(void)
{ yes
++a;
printf("%dn", a); maybe it will print 1, 2, 3?
}

int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
int a;
void foo(void)
{ yes
++a;
}
yes
int main(void)
{
foo();
foo();
foo();
}

#include <stdio.h>
int a;
void foo(void)
{ yes
++a;
}
yes
int main(void)
{ do you know the difference between this code
foo(); snippet and the previous code snippet (with static
foo(); before int a)?
foo();
}

#include <stdio.h>
int a;
void foo(void)
{ yes
++a;
}
yes
int main(void)
foo();
}

not really, or wait a minute, it has do with
private variables and public variables.

#include <stdio.h>
int a;
void foo(void)
{ yes
++a;
}
yes
int main(void)
foo();
}

not really, or wait a minute, it has do with
private variables and public variables.

yeah, something like that...

it will print 1, 2, 3, the variable is still statically
#include <stdio.h> allocated and it will be set to 0

int a;

void foo(void)
{
++a;
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}


int a;

void foo(void) do you know the difference between this
{ code snippet and the previous code
++a; snippet (with static before int a)?
printf("%dn", a);
}

int main(void)
{
foo();
foo();
foo();
}


int a;

void foo(void) do you know the difference between this
{ code snippet and the previous code
++a; snippet (with static before int a)?
printf("%dn", a);
}

int main(void)
{ sure, it has to do with linker visibility. Here the variable is
foo(); accessible from other compilation units, ie the linker can let
foo(); another object ﬁle access this variable. If you add static in
foo(); front, then the variable is local to this compilation unit and
} not visible through the linker.

I am now going to show you something cool!


#include <stdio.h>

void foo(void)
{
int a;
printf("%dn", a);
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}


#include <stdio.h> $ cc foo.c && ./a.out

void foo(void)
{
int a;
printf("%dn", a);
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}


42
void foo(void)
{
int a;
printf("%dn", a);
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}


42
void foo(void)
{ Can you explain this behaviour?
int a;
printf("%dn", a);
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}


42
void foo(void)
int a;
printf("%dn", a);
} eh?

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}


42
void foo(void)
int a;
printf("%dn", a);
} eh?

void bar(void) Perhaps this compiler has a pool of
{ named variables that it reuses. Eg
int a = 42; variable a was used and released in
} bar(), then when foo() needs an
integer names a it will get the
int main(void) variable will get the same memory
{ location. If you rename the variable
bar();
in bar() to, say b, then I don’t think
foo();
you will get 42.
}


42
void foo(void)
int a;
printf("%dn", a);
} eh?

void bar(void) Perhaps this compiler has a pool of
{ named variables that it reuses. Eg
int a = 42; variable a was used and released in
} bar(), then when foo() needs an
integer names a it will get the
int main(void) variable will get the same memory
{ location. If you rename the variable
bar();
in bar() to, say b, then I don’t think
foo();
you will get 42.
}

Yeah, sure...


42
void foo(void)
{ Nice! I love it!
int a;
printf("%dn", a);
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}


42
void foo(void)
{ Nice! I love it!
int a;
printf("%dn", a); You now want me to explain about
} execution stack or activation frames?

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}


42
void foo(void)
{ Nice! I love it!
int a;

void bar(void) I guess you have already demonstrated
{ that you understand it. But what do you
int a = 42;
think might happen if we optimize this
}
code or use another compiler?
int main(void)
{
bar();
foo();
}


42
void foo(void)
{ Nice! I love it!
int a;

void bar(void) I guess you have already demonstrated
{ that you understand it. But what do you
int a = 42;
think might happen if we optimize this
}
code or use another compiler?
int main(void)
{ A lot of things might happen when the optimizer kicks in. In
bar(); this case I would guess that the call to bar() can be skipped as
foo(); it does not have any side effects. Also, I would not be surprised
} if the foo() is inlined in main(), ie no function call. (But since foo
() has linker visibility the object code for the function must still
be created just in case another object ﬁle wants to link with
the function). Anyway, I suspect the value printed will be
something else if you optimize the code.

#include <stdio.h> $ cc -O foo.c && ./a.out
1606415608
void foo(void)
{
int a;
printf("%dn", a);
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}

#include <stdio.h> $ cc -O foo.c && ./a.out
1606415608
void foo(void)
{
int a; Garbage!
printf("%dn", a);
}

void bar(void)
{
int a = 42;
}

int main(void)
{
bar();
foo();
}

So what about this code snippet?


#include <stdio.h>

void foo(void)
{
int a = 41;
a = a++;
printf("%dn", a);
}

int main(void)
{
foo();
}

#include <stdio.h> I would never write code like that.

void foo(void)
{
int a = 41;
a = a++;
printf("%dn", a);
}

int main(void)
{
foo();
}


void foo(void)
That’s nice to hear!
{
int a = 41;
a = a++;
printf("%dn", a);
}

int main(void)
{
foo();
}


void foo(void)
{
int a = 41;
a = a++; But I think the answer is 42
printf("%dn", a);
}

int main(void)
{
foo();
}


void foo(void)
{
int a = 41;
printf("%dn", a);
} Why do you think that?

int main(void)
{
foo();
}


void foo(void)
{
int a = 41;
printf("%dn", a);

int main(void) Because what else can it be?
{
foo();
}


void foo(void)
{
int a = 41;
printf("%dn", a);

{
foo(); Indeed, 42 is exactly what I get when I
} run this on my machine


void foo(void)
{
int a = 41;
printf("%dn", a);

{

hey, you see!


void foo(void)
{
int a = 41;
printf("%dn", a);

{

hey, you see!

But the code is actually undeﬁned.


void foo(void)
{
int a = 41;
printf("%dn", a);

{

hey, you see!

But the code is actually undeﬁned.

Yeah, I told you - I never write code like that

#include <stdio.h> a gets an undeﬁned value

void foo(void)
{
int a = 41;
a = a++;
printf("%dn", a);
}

int main(void)
{
foo();
}


void foo(void)
I don’t get a warning when compiling it,
{
and I do get 42
int a = 41;
a = a++;
printf("%dn", a);
}

int main(void)
{
foo();
}


void foo(void)
{
and I do get 42
int a = 41;
a = a++;
printf("%dn", a); Then you must increase the warning level,
} the value of a is certainly undeﬁned after
the assignment and increment because you
int main(void) violate one of the fundamental rules in C
{ (and C++). The rules for sequencing says
foo(); that you can only update a variable once
} between sequence points. Here you try to
update it two times, and this causes a to
become undeﬁned.


void foo(void)
{
and I do get 42
int a = 41;
a = a++;
become undeﬁned.

So you say a can be whatever? But I do get 42


void foo(void)
{
and I do get 42
int a = 41;
a = a++;
become undeﬁned.

So you say a can be whatever? But I do get 42

Indeed! a can be 42, 41, 43, 0, 1099, or whatever... I am not surprised that your machine gives
you 42... what else can it be here? Or perhaps the compiler choose 42 whenever a value is
undeﬁned ;-)

#include <stdio.h>

int b(void) { puts(“3”); return 3; }
int c(void) { puts(“4”); return 4; }

int main(void)
{
int a = b() + c();
}

#include <stdio.h>


int main(void)
{
int a = b() + c();
}

#include <stdio.h>


int main(void)
{
int a = b() + c();
}

Easy, it prints 3, 4 and then 7

#include <stdio.h>


int main(void)
{
int a = b() + c();
}


Actually, this could also be 4, 3 and then 7

#include <stdio.h>


int main(void)
{
int a = b() + c();
}



Huh? Is the evaluation order undeﬁned?

#include <stdio.h>


int main(void)
{
int a = b() + c();
}




It is not really undeﬁned, it is unspeciﬁed

#include <stdio.h>


int main(void)
{
int a = b() + c();
}





Well, whatever. Lousy compilers. I think it should give us a warning?

#include <stdio.h>


int main(void)
{
int a = b() + c();
}





Well, whatever. Lousy compilers. I think it should give us a warning?

A warning about what?

#include <stdio.h>


int main(void)
{
int a = b() + c();
}

The evaluation order of most expressions in C and C++ are unspeciﬁed, the
compiler can choose to evaluate them in the order that is most optimal for
the target platform. This has to do with sequencing again.

The code is conforming. This code will either print 3, 4, 7 or 4, 3, 7, depending
on the compiler.

#include <stdio.h>


int main(void)
{
int a = b() + c();
}

The evaluation order of most expressions in C and C++ are unspeciﬁed, the
compiler can choose to evaluate them in the order that is most optimal for
the target platform. This has to do with sequencing again.

The code is conforming. This code will either print 3, 4, 7 or 4, 3, 7, depending
on the compiler.

Life would be so easy if more of my colleagues
knew stuff like she does

At this point I think he has just revealed a shallow
understanding of C programming, while she has
excelled in her answers so far.

So what is it that she seems to understand better than most?


• Declaration and Deﬁnition


• Calling conventions and activation frames


• Sequence points


• Sequence points
• Memory model


• Sequence points
• Memory model
• Optimization


• Sequence points
• Memory model
• Optimization
• Knowledge of different C standards

We’d like to share some things about:

Sequence points
Different C standards

What do these code snippets print?


1 int a=41; a++; printf("%dn", a);



2 int a=41; a++ & printf("%dn", a);




3 int a=41; a++ && printf("%dn", a);




3 int a=41; a++ && printf("%dn", a);

4 int a=41; if (a++ < 42) printf("%dn", a);




3 int a=41; a++ && printf("%dn", a);


5 int a=41; a = a++; printf("%dn", a);


1 int a=41; a++; printf("%dn", a); 42


3 int a=41; a++ && printf("%dn", a);




1 int a=41; a++; printf("%dn", a); 42

2 int a=41; a++ & printf("%dn", a); undeﬁned

3 int a=41; a++ && printf("%dn", a);




1 int a=41; a++; printf("%dn", a); 42


3 int a=41; a++ && printf("%dn", a); 42




1 int a=41; a++; printf("%dn", a); 42


3 int a=41; a++ && printf("%dn", a); 42

4 int a=41; if (a++ < 42) printf("%dn", a); 42



1 int a=41; a++; printf("%dn", a); 42


3 int a=41; a++ && printf("%dn", a); 42


5 int a=41; a = a++; printf("%dn", a); undeﬁned


1 int a=41; a++; printf("%dn", a); 42


3 int a=41; a++ && printf("%dn", a); 42


5 int a=41; a = a++; printf("%dn", a); undeﬁned

When exactly do side-effects take place in C and C++?

Sequence Points
A sequence point is a point in the program's
execution sequence where all previous side-
effects shall have taken place and where all
subsequent side-effects shall not have taken place
(5.1.2.3)

Sequence Points - Rule 1
Between the previous and next sequence point an
object shall have its stored value modified at most
once by the evaluation of an expression. (6.5)

a = a++

this is undefined!

Sequence Points - Rule 2
Furthermore, the prior value shall be read only to
determine the value to be stored. (6.5)

a + a++

this is undefined!!

Sequence Points

A lot of developers think C has many sequence points

Sequence Points

The reality is that C has very few sequence points.

This helps to maximize optimization opportunities
for the compiler.

/* K&R C */ // C++ (C++98)

void say_it(a, s) #include <cstdio>
int a;
char s[]; struct X {
{ int a;
printf("%s %dn", s, a); const char * s;
} explicit X(const char * s, int a = 42)
: a(a), s(s) {}
main() void say_it() const {
{ std::printf("%s %dn", s, a);
int a = 42; }
puts("Welcome to classic C"); };
say_it(a, "the answer is");
} int main()
{
X("the answer is").say_it();
/* C89 */ }
void say_it(int a, char * s)
// C99
{
printf("%s %dn", s, a);
struct X
}
{
int a;
main()
char * s;
{
};
int a = 42;
puts("Welcome to C89");
int main(void)
say_it(a, "the answer is");
{
}
puts("Welcome to C99");
struct X x = { .s = "the answer is", .a = 42 };
printf("%s %dn", x.s, x.a);
}

Let’s get back to our two developers...

#include <stdio.h>

struct X { int a; char b; int c; };

int main(void)
{
printf("%dn", sizeof(int));
printf("%dn", sizeof(char));
printf("%dn", sizeof(struct X));
}

#include <stdio.h>


int main(void)
{
}

#include <stdio.h>


int main(void)
{
}

It will print 4, 1 and 12

#include <stdio.h>


int main(void)
{
}


Indeed, it is exactly what I get on my machine

#include <stdio.h>


int main(void)
{
}



Well of course, because sizeof returns the number of bytes. And in C
int is 32 bits or 4 bytes, char is one byte and when the the size of structs
are always rounded up to multiples of 4

#include <stdio.h>


int main(void)
{
}




ok

#include <stdio.h>


int main(void)
{
}




ok

do you want another ice cream?

#include <stdio.h>


int main(void)
{
}

Hmm... first of all, let’s fix the code. The return type of sizeof is
size_t which is not the same as int, so %d is a poor specifier to use in
the format string for printf here

#include <stdio.h>


int main(void)
{
}


ok, what should speciﬁer should we use?

#include <stdio.h>


int main(void)
{
}



Thats a bit tricky. size_t is an unsigned integer type, but on say 32-bit
machines it is usually an unsigned int and on 64-bit machines it is usually an
unsigned long. In C99 however, they introduced a new speciﬁer for printing
size_t values, so %zu might be an option.

#include <stdio.h>


int main(void)
{
}



Thats a bit tricky. size_t is an unsigned integer type, but on say 32-bit
machines it is usually an unsigned int and on 64-bit machines it is usually an
unsigned long. In C99 however, they introduced a new speciﬁer for printing
size_t values, so %zu might be an option.

ok, let’s ﬁx the printf issue, and then you can try to answer the question

#include <stdio.h>


int main(void)
{
printf("%zun", sizeof(int));
printf("%zun", sizeof(char));
printf("%zun", sizeof(struct X));
}

#include <stdio.h>


int main(void)
{
}

Now it all depends on the platform and the compile time options
provided. The only thing we know for sure is that sizeof char is 1. Do
you assume a 64-bit machine?

#include <stdio.h>


int main(void)
{
}


Yes, I have a 64-bit machine running in 32-bit compatibility mode.

#include <stdio.h>


int main(void)
{
}



Then I would like to guess that this prints 4, 1, 12 due to word alignment

#include <stdio.h>


int main(void)
{
}



Then I would like to guess that this prints 4, 1, 12 due to word alignment

But that of course also depends also on compilation ﬂags. It could be 4, 1, 9 if
you ask the compiler to pack the structs, eg -fpack-struct in gcc.

#include <stdio.h>


int main(void)
{
}

4, 1, 12 is indeed what I get on my machine. Why 12?

#include <stdio.h>


int main(void)
{
}


It is very expensive to work on subword data types, so the compiler will optimize
the code by making sure that c is on a word boundary by adding some padding. Also
elements in an array of struct X will now align on word-boundaries.

#include <stdio.h>


int main(void)
{
}



Why is it expensive to work on values that are not aligned?

#include <stdio.h>


int main(void)
{
}



Why is it expensive to work on values that are not aligned?

The instruction set of most processors are optimized for moving a word of data between
memory and CPU. Suppose you want to change a value crossing a word boundary, you would
need to read two words, mask out the value, change the value, mask and write back two words.
Perhaps 10 times slower. Remember, C is focused on execution speed.

#include <stdio.h>


int main(void)
{
}

so what if I add a char d to the struct?

#include <stdio.h>


int main(void)
{
}


If you add it to the end of the struct, my guess is that the size of the struct
becomes 16 on your machine. This is ﬁrst of all because 13 would be a not so
efﬁcient size, what if you have an array of struct X objects? But if you add it
just after char b, then 12 is a more plausible answer.

#include <stdio.h>


int main(void)
{
}



So why doesn’t the compiler reorder the members in the structure to
optimize memory usage, and execution speed?

#include <stdio.h>


int main(void)
{
}



So why doesn’t the compiler reorder the members in the structure to
optimize memory usage, and execution speed?

Some languages actually do that, but C and C++ don’t.

#include <stdio.h>


int main(void)
{
}

so what if I add a char * d to the end of the struct?

#include <stdio.h>


int main(void)
{
}


You said your runtime was 64-bit, so a pointer is probably 8 bytes... Maybe the
struct becomes 20? But perhaps the 64-bit pointer also needs alignment for
efﬁciency? Maybe this code will print 4,1,24?

#include <stdio.h>


int main(void)
{
}


You said your runtime was 64-bit, so a pointer is probably 8 bytes... Maybe the
struct becomes 20? But perhaps the 64-bit pointer also needs alignment for
efﬁciency? Maybe this code will print 4,1,24?

Nice answer! It does not matter what I actually get on my
machine. I like your argument and your insight.


• Some experience with 32-bit vs 64-bit issues


• Memory alignment


• CPU and memory optimization


• CPU and memory optimization
• Spirit of C

We’d like to share some things about:

Memory model
Optimization
The spirit of C

Memory Model
static storage
An object whose identifier is declared with external or internal
linkage, or with the storage-class specifier static has static
storage duration. It’s lifetime is the entire execution of the
program... (6.2.4)
int * immortal(void)
{
static int storage = 42;
return &storage;
}

Memory Model
automatic storage
An object whose identifier is declared with no linkage and
without the storage-class specifier static has automatic
storage duration. ... It’s lifetime extends from entry into the
block with which it is associated until execution of that block
ends in any way. (6.2.4)
int * zombie(void)
{
auto int storage = 42;
return &storage;
}

Memory Model
allocated storage
...storage allocated by calls to calloc, malloc, and realloc...
The lifetime of an allocated object extends from the allocation
to the dealloction. (7.20.3)

int * finite(void)
{
int * ptr = malloc(sizeof *ptr);
*ptr = 42;
return ptr;
}

Deep C

More Related Content

Deep C