SlideShare a Scribd company logo
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
Deep C
Deep C
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:
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);
               }
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);
               }

              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;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }


  One candidate might say:
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

                                     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.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

                                     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...
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

But another candidate might use this as an opportunity to start
demonstrating a deeper understanding. She might say things like:
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

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.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

and then she elaborates
a bit by saying:
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

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:
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

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:
                               However a proper C compiler will create an implicit
                               declaration for the function printf(), compile this
                                              code into an object file.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

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:
                               However a proper C compiler will create an implicit
                               declaration for the function printf(), compile this
                                              code into an object file.

                              And when linked with a standard library, it will find a
                             definition of printf()that accidentally will match the
                                              implicit declaration.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

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:
                               However a proper C compiler will create an implicit
                               declaration for the function printf(), compile this
                                              code into an object file.

                              And when linked with a standard library, it will find a
                             definition of printf()that accidentally will match the
                                              implicit declaration.

                            So the program above will actually compile, link and run.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

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:
                               However a proper C compiler will create an implicit
                               declaration for the function printf(), compile this
                                              code into an object file.

                              And when linked with a standard library, it will find a
                             definition of printf()that accidentally will match the
                                              implicit declaration.

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


                                    You might get a warning though.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

and while she is on the roll, she might continue with:
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

and while she is on the roll, she might continue with:
                             If this is C99, the exit value is defined 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 undefined garbage value.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

and while she is on the roll, she might continue with:
                             If this is C99, the exit value is defined 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 undefined 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.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

and while she is on the roll, she might continue with:
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }

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


                               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 definitions does not hurt.
What will happen if you try to compile, link and run this program?
                     int main()
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                     int main(void)
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                      int main(void)
                      {
                          int a = 42;
                          printf(“%dn”, a);
                      }

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.
What will happen if you try to compile, link and run this program?
                     int main(void)
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                     int main(void)
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                     int main(void)
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }




                                  ah, remember to include an explicit
                                   declaration of printf() as well
What will happen if you try to compile, link and run this program?
                     int main(void)
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?

                     int main(void)
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

                     int main(void)
                     {
                         int a = 42;
                         printf(“%dn”, a);
                     }
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




                               now, this is a darn cute little C program! Isn’t it?
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




and here is what I get when compiling, linking and running the
above program on my machine:
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c
   $ cc foo.o
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c
   $ cc foo.o
   $ ./a.out
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c
   $ cc foo.o
   $ ./a.out
   42
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c
   $ cc foo.o
   $ ./a.out
   42
   $ echo $?
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c
   $ cc foo.o
   $ ./a.out
   42
   $ echo $?
   3
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c           $ cc -std=c99 -c foo.c
   $ cc foo.o
   $ ./a.out
   42
   $ echo $?
   3
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c           $ cc -std=c99 -c foo.c
   $ cc foo.o                       $ cc foo.o
   $ ./a.out
   42
   $ echo $?
   3
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c           $ cc -std=c99 -c foo.c
   $ cc foo.o                       $ cc foo.o
   $ ./a.out                        $ ./a.out
   42
   $ echo $?
   3
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c           $ cc -std=c99 -c foo.c
   $ cc foo.o                       $ cc foo.o
   $ ./a.out                        $ ./a.out
   42                               42
   $ echo $?
   3
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c           $ cc -std=c99 -c foo.c
   $ cc foo.o                       $ cc foo.o
   $ ./a.out                        $ ./a.out
   42                               42
   $ echo $?                        $ echo $?
   3
What will happen if you try to compile, link and run this program?
                     #include <stdio.h>

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




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

   $ cc -std=c89 -c foo.c           $ cc -std=c99 -c foo.c
   $ cc foo.o                       $ cc foo.o
   $ ./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?
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 find out how deep their knowledge of C and C++ is...
Let’s find 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)
{
    int a = 3;
    ++a;
    printf("%dn", a);
}

int main(void)
{
    foo();
    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 = 3;
    ++a;
    printf("%dn", a);
}

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

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

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

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

int main(void)
{
    foo();
    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 undefined? do you get garbage values?

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

int main(void)
{
    foo();
    foo();
    foo();
}
#include <stdio.h>       eh, is it undefined? do you get garbage values?

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

int main(void)
{
    foo();
    foo();
    foo();
}
#include <stdio.h>       eh, is it undefined? do you get garbage values?

void foo(void)
                                              No, you get 1, then 2, then 3
{
    static int a;
    ++a;                  ok, I see... why?
    printf("%dn", a);
}

int main(void)
{
    foo();
    foo();
    foo();
}
#include <stdio.h>       eh, is it undefined? do you get garbage values?

void foo(void)
                                              No, you get 1, then 2, then 3
{
    static int a;
    ++a;                  ok, I see... why?
    printf("%dn", a);
}                                    because static variables are set to 0

int main(void)
{
    foo();
    foo();
    foo();
}
#include <stdio.h>       eh, is it undefined? do you get garbage values?

void foo(void)
                                              No, you get 1, then 2, then 3
{
    static int a;
    ++a;                  ok, I see... why?
    printf("%dn", a);
}                                    because static variables are set to 0

int main(void)
{
    foo();
    foo();
    foo();
}
#include <stdio.h>       eh, is it undefined? do you get garbage values?

void foo(void)
                                                No, you get 1, then 2, then 3
{
    static int a;
    ++a;                   ok, I see... why?
    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)
{
    static int a;
    ++a;
    printf("%dn", a);
}

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

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

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

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

int main(void)
{
    foo();
    foo();
    foo();
}
#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();
}
Now you get 1, then 1, then 1
#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();
}
Now you get 1, then 1, then 1
#include <stdio.h>
                            Ehm, why do you think that will happen?
void foo(void)
{                        Because you said they where initialized to 0
    int a;
    ++a;
    printf("%dn", a);
}

int main(void)
{
    foo();
    foo();
    foo();
}
Now you get 1, then 1, then 1
#include <stdio.h>
                            Ehm, why do you think that will happen?
void foo(void)
{                        Because you said they where initialized to 0
    int a;
    ++a;                          But this is not a static variable
    printf("%dn", a);
}

int main(void)
{
    foo();
    foo();
    foo();
}
Now you get 1, then 1, then 1
#include <stdio.h>
                            Ehm, why do you think that will happen?
void foo(void)
{                        Because you said they where initialized to 0
    int a;
    ++a;                          But this is not a static variable
    printf("%dn", a);
}                           ah, then you get three garbage values

int main(void)
{
    foo();
    foo();
    foo();
}
Now you get 1, then 1, then 1
#include <stdio.h>
                            Ehm, why do you think that will happen?
void foo(void)
{                        Because you said they where initialized to 0
    int a;
    ++a;                          But this is not a static variable
    printf("%dn", a);
}                           ah, then you get three garbage values

int main(void)
{
    foo();
    foo();
    foo();
}
Now you get 1, then 1, then 1
#include <stdio.h>
                                Ehm, why do you think that will happen?
void foo(void)
{                           Because you said they where initialized to 0
    int a;
    ++a;                              But this is not a static variable
    printf("%dn", a);
}                               ah, then you get three garbage values

int main(void)           the value of a will be undefinded, 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.
Now you get 1, then 1, then 1
#include <stdio.h>
                                Ehm, why do you think that will happen?
void foo(void)
{                           Because you said they where initialized to 0
    int a;
    ++a;                              But this is not a static variable
    printf("%dn", a);
}                               ah, then you get three garbage values

int main(void)           the value of a will be undefinded, 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.

                                on my machine I actually get, 1, then 2, then 3
Now you get 1, then 1, then 1
#include <stdio.h>
                                Ehm, why do you think that will happen?
void foo(void)
{                           Because you said they where initialized to 0
    int a;
    ++a;                              But this is not a static variable
    printf("%dn", a);
}                               ah, then you get three garbage values

int main(void)           the value of a will be undefinded, 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.

                                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>

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

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

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

int main(void)
{
    foo();
    foo();
    foo();
}
#include <stdio.h>       Why do you think static variables are set to 0,
                         while auto variables are not initialized?
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();
}
#include <stdio.h>       Why do you think static variables are set to 0,
                         while auto variables are not initialized?
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();                   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.
#include <stdio.h>        Why do you think static variables are set to 0,
                          while auto variables are not initialized?
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();                     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>

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

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


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

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



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

int main(void)
{
    foo();
    foo();
    foo();
}
#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();
}
#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;
                         because a is static, and therefore initialized to 0
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;
                         because a is static, and therefore initialized to 0
void foo(void)
{                                               I agree...
    ++a;
    printf("%dn", a);                         cool!
}

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>

int a;

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

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

int a;

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

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();
}
garbage, garbage, garbage
#include <stdio.h>
                             why do you think that?
int a;

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

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

int main(void)
{
    foo();
    foo();
    foo();
}
garbage, garbage, garbage
#include <stdio.h>
                              why do you think that?
int a;
                          oh, is it still initialized to 0?
void foo(void)
{                                                       yes
    ++a;
    printf("%dn", a);
}

int main(void)
{
    foo();
    foo();
    foo();
}
garbage, garbage, garbage
#include <stdio.h>
                              why do you think that?
int a;
                          oh, is it still initialized to 0?
void foo(void)
{                                                       yes
    ++a;
    printf("%dn", a);    maybe it will print 1, 2, 3?
}

int main(void)
{
    foo();
    foo();
    foo();
}
garbage, garbage, garbage
#include <stdio.h>
                              why do you think that?
int a;
                          oh, is it still initialized to 0?
void foo(void)
{                                                       yes
    ++a;
    printf("%dn", a);    maybe it will print 1, 2, 3?
}
                                                         yes
int main(void)
{
    foo();
    foo();
    foo();
}
garbage, garbage, garbage
#include <stdio.h>
                                           why do you think that?
int a;
                                       oh, is it still initialized to 0?
void foo(void)
{                                                                    yes
    ++a;
    printf("%dn", a);                 maybe it will print 1, 2, 3?
}
                                                                      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();
}
garbage, garbage, garbage
#include <stdio.h>
                                               why do you think that?
int a;
                                           oh, is it still initialized to 0?
void foo(void)
{                                                                        yes
    ++a;
    printf("%dn", a);                      maybe it will print 1, 2, 3?
}
                                                                          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();
}

                         not really, or wait a minute, it has do with
                           private variables and public variables.
garbage, garbage, garbage
#include <stdio.h>
                                               why do you think that?
int a;
                                           oh, is it still initialized to 0?
void foo(void)
{                                                                        yes
    ++a;
    printf("%dn", a);                      maybe it will print 1, 2, 3?
}
                                                                          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();
}

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

                                           yeah, something like that...
#include <stdio.h>

int a;

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

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

int a;

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

int main(void)
{
    foo();
    foo();
    foo();
}
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();
}
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)                    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();
}
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)                             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 file 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.
Deep C
I am now going to show you something cool!
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();
}
I am now going to show you something cool!


#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();
}
I am now going to show you something cool!


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

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

int main(void)
{
    bar();
    foo();
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  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();
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  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();
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  42
void foo(void)
{                                         Can you explain this behaviour?
    int a;
    printf("%dn", a);
}                                                    eh?

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

int main(void)
{
    bar();
    foo();
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  42
void foo(void)
{                                         Can you explain this behaviour?
    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.
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  42
void foo(void)
{                                         Can you explain this behaviour?
    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...
I am now going to show you something cool!


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

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

int main(void)
{
    bar();
    foo();
}
I am now going to show you something cool!


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

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

int main(void)
{
    bar();
    foo();
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  42
void foo(void)
{                           Nice! I love it!
    int a;
    printf("%dn", a);
}

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

int main(void)
{
    bar();
    foo();
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  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();
}
I am now going to show you something cool!


#include <stdio.h>                $ cc foo.c && ./a.out
                                  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)                                  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();
}
I am now going to show you something cool!


#include <stdio.h>                 $ cc foo.c && ./a.out
                                   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)                                   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 file 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;
    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?
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>

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();
}
#include <stdio.h>       I would never write code like that.

void foo(void)
                                      That’s nice to hear!
{
    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)
                                      That’s nice to hear!
{
    int a = 41;
    a = a++;                     But I think the answer is 42
    printf("%dn", a);
}

int main(void)
{
    foo();
}
#include <stdio.h>       I would never write code like that.

void foo(void)
                                      That’s nice to hear!
{
    int a = 41;
    a = a++;                     But I think the answer is 42
    printf("%dn", a);
}                                   Why do you think that?

int main(void)
{
    foo();
}
#include <stdio.h>       I would never write code like that.

void foo(void)
                                      That’s nice to hear!
{
    int a = 41;
    a = a++;                     But I think the answer is 42
    printf("%dn", a);
}                                   Why do you think that?

int main(void)                 Because what else can it be?
{
    foo();
}
#include <stdio.h>       I would never write code like that.

void foo(void)
                                      That’s nice to hear!
{
    int a = 41;
    a = a++;                     But I think the answer is 42
    printf("%dn", a);
}                                   Why do you think that?

int main(void)                 Because what else can it be?
{
    foo();                 Indeed, 42 is exactly what I get when I
}                                 run this on my machine
#include <stdio.h>       I would never write code like that.

void foo(void)
                                      That’s nice to hear!
{
    int a = 41;
    a = a++;                     But I think the answer is 42
    printf("%dn", a);
}                                   Why do you think that?

int main(void)                 Because what else can it be?
{
    foo();                 Indeed, 42 is exactly what I get when I
}                                 run this on my machine

                                       hey, you see!
#include <stdio.h>       I would never write code like that.

void foo(void)
                                      That’s nice to hear!
{
    int a = 41;
    a = a++;                     But I think the answer is 42
    printf("%dn", a);
}                                   Why do you think that?

int main(void)                 Because what else can it be?
{
    foo();                 Indeed, 42 is exactly what I get when I
}                                 run this on my machine

                                       hey, you see!

                            But the code is actually undefined.
#include <stdio.h>                 I would never write code like that.

void foo(void)
                                                 That’s nice to hear!
{
    int a = 41;
    a = a++;                                But I think the answer is 42
    printf("%dn", a);
}                                             Why do you think that?

int main(void)                            Because what else can it be?
{
    foo();                            Indeed, 42 is exactly what I get when I
}                                            run this on my machine

                                                  hey, you see!

                                      But the code is actually undefined.


                         Yeah, I told you - I never write code like that
#include <stdio.h>

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

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

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

int main(void)
{
    foo();
}
#include <stdio.h>       a gets an undefined value

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

int main(void)
{
    foo();
}
#include <stdio.h>        a gets an undefined value

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();
}
#include <stdio.h>          a gets an undefined value

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);   Then you must increase the warning level,
}                        the value of a is certainly undefined 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 undefined.
#include <stdio.h>                  a gets an undefined value

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);          Then you must increase the warning level,
}                               the value of a is certainly undefined 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 undefined.

                         So you say a can be whatever? But I do get 42
#include <stdio.h>                                      a gets an undefined value

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);                              Then you must increase the warning level,
}                                                   the value of a is certainly undefined 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 undefined.

                                            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
undefined ;-)
So what about this code snippet?
So what about this code snippet?
#include <stdio.h>

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

int main(void)
{
    int a = b() + c();
    printf(“%dn”, a);
}
#include <stdio.h>

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

int main(void)
{
    int a = b() + c();
    printf(“%dn”, a);
}
#include <stdio.h>

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

     int main(void)
     {
         int a = b() + c();
         printf(“%dn”, a);
     }


Easy, it prints 3, 4 and then 7
#include <stdio.h>

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

     int main(void)
     {
         int a = b() + c();
         printf(“%dn”, a);
     }


Easy, it prints 3, 4 and then 7

                              Actually, this could also be 4, 3 and then 7
#include <stdio.h>

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

     int main(void)
     {
         int a = b() + c();
         printf(“%dn”, a);
     }


Easy, it prints 3, 4 and then 7

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

         Huh? Is the evaluation order undefined?
#include <stdio.h>

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

     int main(void)
     {
         int a = b() + c();
         printf(“%dn”, a);
     }


Easy, it prints 3, 4 and then 7

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

         Huh? Is the evaluation order undefined?

                       It is not really undefined, it is unspecified
#include <stdio.h>

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

     int main(void)
     {
         int a = b() + c();
         printf(“%dn”, a);
     }


Easy, it prints 3, 4 and then 7

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

         Huh? Is the evaluation order undefined?

                       It is not really undefined, it is unspecified

        Well, whatever. Lousy compilers. I think it should give us a warning?
#include <stdio.h>

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

     int main(void)
     {
         int a = b() + c();
         printf(“%dn”, a);
     }


Easy, it prints 3, 4 and then 7

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

         Huh? Is the evaluation order undefined?

                       It is not really undefined, it is unspecified

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

                                                      A warning about what?
#include <stdio.h>

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

int main(void)
{
    int a = b() + c();
    printf(“%dn”, a);
}
#include <stdio.h>

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

int main(void)
{
    int a = b() + c();
    printf(“%dn”, a);
}
#include <stdio.h>

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

      int main(void)
      {
          int a = b() + c();
          printf(“%dn”, a);
      }


The evaluation order of most expressions in C and C++ are unspecified, 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 b(void) { puts(“3”); return 3; }
      int c(void) { puts(“4”); return 4; }

      int main(void)
      {
          int a = b() + c();
          printf(“%dn”, a);
      }


The evaluation order of most expressions in C and C++ are unspecified, 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
Deep C
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?
So what is it that she seems to understand better than most?



               • Declaration and Definition
So what is it that she seems to understand better than most?



               • Declaration and Definition
               • Calling conventions and activation frames
So what is it that she seems to understand better than most?



               • Declaration and Definition
               • Calling conventions and activation frames
               • Sequence points
So what is it that she seems to understand better than most?



               • Declaration and Definition
               • Calling conventions and activation frames
               • Sequence points
               • Memory model
So what is it that she seems to understand better than most?



               • Declaration and Definition
               • Calling conventions and activation frames
               • Sequence points
               • Memory model
               • Optimization
So what is it that she seems to understand better than most?



               • Declaration and Definition
               • Calling conventions and activation frames
               • 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?
What do these code snippets print?

1   int a=41; a++; printf("%dn", a);
What do these code snippets print?

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


2   int a=41; a++ & printf("%dn", a);
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);
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);



4   int a=41; if (a++ < 42) printf("%dn", a);
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);



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


5   int a=41; a = a++; printf("%dn", a);
What do these code snippets print?

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

2   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);


5   int a=41; a = a++; printf("%dn", a);
What do these code snippets print?

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

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

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



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


5   int a=41; a = a++; printf("%dn", a);
What do these code snippets print?

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

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

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

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


5   int a=41; a = a++; printf("%dn", a);
What do these code snippets print?

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

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

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

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

5   int a=41; a = a++; printf("%dn", a);
What do these code snippets print?

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

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

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

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

5   int a=41; a = a++; printf("%dn", a);        undefined
What do these code snippets print?

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

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

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

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

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

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...
So what about this code snippet?
So what about this code snippet?
#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>

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>

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

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

  It will print 4, 1 and 12
#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));
}

  It will print 4, 1 and 12

   Indeed, it is exactly what I get on my machine
#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));
}

    It will print 4, 1 and 12

    Indeed, it is exactly what I get on my machine

 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>

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

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

    It will print 4, 1 and 12

    Indeed, it is exactly what I get on my machine

 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

                                                             ok
#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));
}

    It will print 4, 1 and 12

    Indeed, it is exactly what I get on my machine

 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

                                                               ok

                                             do you want another ice cream?
#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>

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>

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

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

  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>

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

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

  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

                            ok, what should specifier should we use?
#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));
      }

  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

                             ok, what should specifier should we use?

        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 specifier for printing
                         size_t values, so %zu might be an option.
#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));
       }

  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

                              ok, what should specifier should we use?

         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 specifier for printing
                          size_t values, so %zu might be an option.

ok, let’s fix the printf issue, and then you can try to answer the question
#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>

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

int main(void)
{
    printf("%zun", sizeof(int));
    printf("%zun", sizeof(char));
    printf("%zun", sizeof(struct X));
}
#include <stdio.h>

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

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


  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>

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

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


  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?

      Yes, I have a 64-bit machine running in 32-bit compatibility mode.
#include <stdio.h>

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

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


  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?

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

      Then I would like to guess that this prints 4, 1, 12 due to word alignment
#include <stdio.h>

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

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


  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?

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

      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 flags. It could be 4, 1, 9 if
          you ask the compiler to pack the structs, eg -fpack-struct in gcc.
#include <stdio.h>

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

int main(void)
{
    printf("%zun", sizeof(int));
    printf("%zun", sizeof(char));
    printf("%zun", sizeof(struct X));
}
#include <stdio.h>

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

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


 4, 1, 12 is indeed what I get on my machine. Why 12?
#include <stdio.h>

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

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


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

 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>

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

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


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

 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.

           Why is it expensive to work on values that are not aligned?
#include <stdio.h>

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

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


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

              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.

                        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>

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

int main(void)
{
    printf("%zun", sizeof(int));
    printf("%zun", sizeof(char));
    printf("%zun", sizeof(struct X));
}
#include <stdio.h>

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

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


     so what if I add a char d to the struct?
#include <stdio.h>

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

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


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

  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 first of all because 13 would be a not so
efficient 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>

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

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


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

  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 first of all because 13 would be a not so
efficient 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.

    So why doesn’t the compiler reorder the members in the structure to
              optimize memory usage, and execution speed?
#include <stdio.h>

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

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


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

  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 first of all because 13 would be a not so
efficient 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.

    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>

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

int main(void)
{
    printf("%zun", sizeof(int));
    printf("%zun", sizeof(char));
    printf("%zun", sizeof(struct X));
}
#include <stdio.h>

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

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


 so what if I add a char * d to the end of the struct?
#include <stdio.h>

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

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


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

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
                efficiency? Maybe this code will print 4,1,24?
#include <stdio.h>

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

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


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

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
                efficiency? 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.
So what is it that she seems to understand better than most?
So what is it that she seems to understand better than most?




              • Some experience with 32-bit vs 64-bit issues
So what is it that she seems to understand better than most?




              • Some experience with 32-bit vs 64-bit issues
              • Memory alignment
So what is it that she seems to understand better than most?




              • Some experience with 32-bit vs 64-bit issues
              • Memory alignment
              • CPU and memory optimization
So what is it that she seems to understand better than most?




              • Some experience with 32-bit vs 64-bit issues
              • Memory alignment
              • 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
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C
Deep C

More Related Content

What's hot

C programming
C programmingC programming
C programming
Sivakumar Palani
 
88 c-programs
88 c-programs88 c-programs
88 c-programs
Leandro Schenone
 
OOP in C++
OOP in C++OOP in C++
OOP in C++
ppd1961
 
Introduction to c++ ppt 1
Introduction to c++ ppt 1Introduction to c++ ppt 1
Introduction to c++ ppt 1
Prof. Dr. K. Adisesha
 
C program compiler presentation
C program compiler presentationC program compiler presentation
C program compiler presentation
Rigvendra Kumar Vardhan
 
Functions in C++
Functions in C++Functions in C++
Functions in C++
Mohammed Sikander
 
SPL 9 | Scope of Variables in C
SPL 9 | Scope of Variables in CSPL 9 | Scope of Variables in C
SPL 9 | Scope of Variables in C
Mohammad Imam Hossain
 
Book ppt
Book pptBook ppt
Book ppt
FALLEE31188
 
Understand more about C
Understand more about CUnderstand more about C
Understand more about C
Yi-Hsiu Hsu
 
Introduction to pointers and memory management in C
Introduction to pointers and memory management in CIntroduction to pointers and memory management in C
Introduction to pointers and memory management in C
Uri Dekel
 
Advanced C - Part 1
Advanced C - Part 1 Advanced C - Part 1
C basics
C   basicsC   basics
C Programming Language Tutorial for beginners - JavaTpoint
C Programming Language Tutorial for beginners - JavaTpointC Programming Language Tutorial for beginners - JavaTpoint
C Programming Language Tutorial for beginners - JavaTpoint
JavaTpoint.Com
 
Introduction to Basic C programming 01
Introduction to Basic C programming 01Introduction to Basic C programming 01
Introduction to Basic C programming 01
Wingston
 
Learn C Programming Language by Using GDB
Learn C Programming Language by Using GDBLearn C Programming Language by Using GDB
Learn C Programming Language by Using GDB
National Cheng Kung University
 
Object oriented programming c++
Object oriented programming c++Object oriented programming c++
Object oriented programming c++
Ankur Pandey
 
C vs c++
C vs c++C vs c++
C vs c++
Gaurav Badhan
 
Linkers
LinkersLinkers
Introduction to compiler
Introduction to compilerIntroduction to compiler
Introduction to compiler
Abha Damani
 
Oops concept in c++ unit 3 -topic 4
Oops concept in c++ unit 3 -topic 4Oops concept in c++ unit 3 -topic 4
Oops concept in c++ unit 3 -topic 4
MOHIT TOMAR
 

What's hot (20)

C programming
C programmingC programming
C programming
 
88 c-programs
88 c-programs88 c-programs
88 c-programs
 
OOP in C++
OOP in C++OOP in C++
OOP in C++
 
Introduction to c++ ppt 1
Introduction to c++ ppt 1Introduction to c++ ppt 1
Introduction to c++ ppt 1
 
C program compiler presentation
C program compiler presentationC program compiler presentation
C program compiler presentation
 
Functions in C++
Functions in C++Functions in C++
Functions in C++
 
SPL 9 | Scope of Variables in C
SPL 9 | Scope of Variables in CSPL 9 | Scope of Variables in C
SPL 9 | Scope of Variables in C
 
Book ppt
Book pptBook ppt
Book ppt
 
Understand more about C
Understand more about CUnderstand more about C
Understand more about C
 
Introduction to pointers and memory management in C
Introduction to pointers and memory management in CIntroduction to pointers and memory management in C
Introduction to pointers and memory management in C
 
Advanced C - Part 1
Advanced C - Part 1 Advanced C - Part 1
Advanced C - Part 1
 
C basics
C   basicsC   basics
C basics
 
C Programming Language Tutorial for beginners - JavaTpoint
C Programming Language Tutorial for beginners - JavaTpointC Programming Language Tutorial for beginners - JavaTpoint
C Programming Language Tutorial for beginners - JavaTpoint
 
Introduction to Basic C programming 01
Introduction to Basic C programming 01Introduction to Basic C programming 01
Introduction to Basic C programming 01
 
Learn C Programming Language by Using GDB
Learn C Programming Language by Using GDBLearn C Programming Language by Using GDB
Learn C Programming Language by Using GDB
 
Object oriented programming c++
Object oriented programming c++Object oriented programming c++
Object oriented programming c++
 
C vs c++
C vs c++C vs c++
C vs c++
 
Linkers
LinkersLinkers
Linkers
 
Introduction to compiler
Introduction to compilerIntroduction to compiler
Introduction to compiler
 
Oops concept in c++ unit 3 -topic 4
Oops concept in c++ unit 3 -topic 4Oops concept in c++ unit 3 -topic 4
Oops concept in c++ unit 3 -topic 4
 

Viewers also liked

MinGw Compiler
MinGw CompilerMinGw Compiler
MinGw Compiler
Avnish Patel
 
Introduction to Perl - Day 1
Introduction to Perl - Day 1Introduction to Perl - Day 1
Introduction to Perl - Day 1
Dave Cross
 
Gccgdb
GccgdbGccgdb
Gccgdb
selva raj
 
GCC Compiler as a Performance Testing tool for C programs
GCC Compiler as a Performance Testing tool for C programsGCC Compiler as a Performance Testing tool for C programs
GCC Compiler as a Performance Testing tool for C programs
Daniel Ilunga
 
Gcc opt
Gcc optGcc opt
Gcc opt
Mark Veltzer
 
Compiling Under Linux
Compiling Under LinuxCompiling Under Linux
Compiling Under Linux
PierreMASURE
 
C compilation process
C compilation processC compilation process
C compilation process
RajKumar Rampelli
 
HRM - PM in GCC
HRM - PM in GCCHRM - PM in GCC
HRM - PM in GCC
Muhammad Danish Azad
 
G++ & GCC
G++ & GCCG++ & GCC
G++ & GCC
Beste Ekmen
 
NetBeans para Java, C, C++
NetBeans para Java, C, C++NetBeans para Java, C, C++
NetBeans para Java, C, C++
Manuel Antonio
 
Principles of compiler design
Principles of compiler designPrinciples of compiler design
Principles of compiler design
Janani Parthiban
 
GCC, GNU compiler collection
GCC, GNU compiler collectionGCC, GNU compiler collection
GCC, GNU compiler collection
Alberto Bustamante Reyes
 
How it's made: C++ compilers (GCC)
How it's made: C++ compilers (GCC)How it's made: C++ compilers (GCC)
How it's made: C++ compilers (GCC)
Sławomir Zborowski
 
GNU Compiler Collection - August 2005
GNU Compiler Collection - August 2005GNU Compiler Collection - August 2005
GNU Compiler Collection - August 2005
Saleem Ansari
 
GEM - GNU C Compiler Extensions Framework
GEM - GNU C Compiler Extensions FrameworkGEM - GNU C Compiler Extensions Framework
GEM - GNU C Compiler Extensions Framework
Alexey Smirnov
 
GCC
GCCGCC

Viewers also liked (16)

MinGw Compiler
MinGw CompilerMinGw Compiler
MinGw Compiler
 
Introduction to Perl - Day 1
Introduction to Perl - Day 1Introduction to Perl - Day 1
Introduction to Perl - Day 1
 
Gccgdb
GccgdbGccgdb
Gccgdb
 
GCC Compiler as a Performance Testing tool for C programs
GCC Compiler as a Performance Testing tool for C programsGCC Compiler as a Performance Testing tool for C programs
GCC Compiler as a Performance Testing tool for C programs
 
Gcc opt
Gcc optGcc opt
Gcc opt
 
Compiling Under Linux
Compiling Under LinuxCompiling Under Linux
Compiling Under Linux
 
C compilation process
C compilation processC compilation process
C compilation process
 
HRM - PM in GCC
HRM - PM in GCCHRM - PM in GCC
HRM - PM in GCC
 
G++ & GCC
G++ & GCCG++ & GCC
G++ & GCC
 
NetBeans para Java, C, C++
NetBeans para Java, C, C++NetBeans para Java, C, C++
NetBeans para Java, C, C++
 
Principles of compiler design
Principles of compiler designPrinciples of compiler design
Principles of compiler design
 
GCC, GNU compiler collection
GCC, GNU compiler collectionGCC, GNU compiler collection
GCC, GNU compiler collection
 
How it's made: C++ compilers (GCC)
How it's made: C++ compilers (GCC)How it's made: C++ compilers (GCC)
How it's made: C++ compilers (GCC)
 
GNU Compiler Collection - August 2005
GNU Compiler Collection - August 2005GNU Compiler Collection - August 2005
GNU Compiler Collection - August 2005
 
GEM - GNU C Compiler Extensions Framework
GEM - GNU C Compiler Extensions FrameworkGEM - GNU C Compiler Extensions Framework
GEM - GNU C Compiler Extensions Framework
 
GCC
GCCGCC
GCC
 

Similar to Deep C

Aptitute question papers in c
Aptitute question papers in cAptitute question papers in c
Aptitute question papers in c
Pantech ProEd Pvt Ltd
 
C programming day#1
C programming day#1C programming day#1
C programming day#1
Mohamed Fawzy
 
Programming Fundamentals lecture 5
Programming Fundamentals lecture 5Programming Fundamentals lecture 5
Programming Fundamentals lecture 5
REHAN IJAZ
 
C language introduction geeksfor geeks
C language introduction   geeksfor geeksC language introduction   geeksfor geeks
C language introduction geeksfor geeks
AashutoshChhedavi
 
2 debugging-c
2 debugging-c2 debugging-c
2 debugging-c
Subhashis Pradhan
 
C language questions_answers_explanation
C language questions_answers_explanationC language questions_answers_explanation
C language questions_answers_explanation
srinath v
 
Datastructure notes
Datastructure notesDatastructure notes
Datastructure notes
Srikanth
 
Programming in c
Programming in cProgramming in c
Programming in c
Ashutosh Srivasatava
 
The basics of c programming
The basics of c programmingThe basics of c programming
The basics of c programming
Muhammed Thanveer M
 
Boo Manifesto
Boo ManifestoBoo Manifesto
Boo Manifesto
hu hans
 
C programming
C programmingC programming
C programming
saniabhalla
 
c-for-c-programmers.pdf
c-for-c-programmers.pdfc-for-c-programmers.pdf
c-for-c-programmers.pdf
Salar32
 
complete data structure
complete data structurecomplete data structure
complete data structure
Anuj Arora
 
Datastructurenotes 100627004340-phpapp01
Datastructurenotes 100627004340-phpapp01Datastructurenotes 100627004340-phpapp01
Datastructurenotes 100627004340-phpapp01
Getachew Ganfur
 
Unit-IV.pptx
Unit-IV.pptxUnit-IV.pptx
Unit-IV.pptx
Mehul Desai
 
01 Jo P Jan 07
01 Jo P Jan 0701 Jo P Jan 07
01 Jo P Jan 07
Ganesh Samarthyam
 
In C Programming create a program that converts a number from decimal.docx
In C Programming create a program that converts a number from decimal.docxIn C Programming create a program that converts a number from decimal.docx
In C Programming create a program that converts a number from decimal.docx
tristans3
 
05 -working_with_the_preproce
05  -working_with_the_preproce05  -working_with_the_preproce
05 -working_with_the_preproce
Hector Garzo
 
Chowtodoprogram solutions
Chowtodoprogram solutionsChowtodoprogram solutions
Chowtodoprogram solutions
Musa Gürbüz
 
What is turbo c and how it works
What is turbo c and how it worksWhat is turbo c and how it works
What is turbo c and how it works
Mark John Lado, MIT
 

Similar to Deep C (20)

Aptitute question papers in c
Aptitute question papers in cAptitute question papers in c
Aptitute question papers in c
 
C programming day#1
C programming day#1C programming day#1
C programming day#1
 
Programming Fundamentals lecture 5
Programming Fundamentals lecture 5Programming Fundamentals lecture 5
Programming Fundamentals lecture 5
 
C language introduction geeksfor geeks
C language introduction   geeksfor geeksC language introduction   geeksfor geeks
C language introduction geeksfor geeks
 
2 debugging-c
2 debugging-c2 debugging-c
2 debugging-c
 
C language questions_answers_explanation
C language questions_answers_explanationC language questions_answers_explanation
C language questions_answers_explanation
 
Datastructure notes
Datastructure notesDatastructure notes
Datastructure notes
 
Programming in c
Programming in cProgramming in c
Programming in c
 
The basics of c programming
The basics of c programmingThe basics of c programming
The basics of c programming
 
Boo Manifesto
Boo ManifestoBoo Manifesto
Boo Manifesto
 
C programming
C programmingC programming
C programming
 
c-for-c-programmers.pdf
c-for-c-programmers.pdfc-for-c-programmers.pdf
c-for-c-programmers.pdf
 
complete data structure
complete data structurecomplete data structure
complete data structure
 
Datastructurenotes 100627004340-phpapp01
Datastructurenotes 100627004340-phpapp01Datastructurenotes 100627004340-phpapp01
Datastructurenotes 100627004340-phpapp01
 
Unit-IV.pptx
Unit-IV.pptxUnit-IV.pptx
Unit-IV.pptx
 
01 Jo P Jan 07
01 Jo P Jan 0701 Jo P Jan 07
01 Jo P Jan 07
 
In C Programming create a program that converts a number from decimal.docx
In C Programming create a program that converts a number from decimal.docxIn C Programming create a program that converts a number from decimal.docx
In C Programming create a program that converts a number from decimal.docx
 
05 -working_with_the_preproce
05  -working_with_the_preproce05  -working_with_the_preproce
05 -working_with_the_preproce
 
Chowtodoprogram solutions
Chowtodoprogram solutionsChowtodoprogram solutions
Chowtodoprogram solutions
 
What is turbo c and how it works
What is turbo c and how it worksWhat is turbo c and how it works
What is turbo c and how it works
 

Recently uploaded

Feature sql server terbaru performance.pptx
Feature sql server terbaru performance.pptxFeature sql server terbaru performance.pptx
Feature sql server terbaru performance.pptx
ssuser1915fe1
 
Communications Mining Series - Zero to Hero - Session 3
Communications Mining Series - Zero to Hero - Session 3Communications Mining Series - Zero to Hero - Session 3
Communications Mining Series - Zero to Hero - Session 3
DianaGray10
 
Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery
Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery
Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery
sunilverma7884
 
Acumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdf
Acumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdfAcumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdf
Acumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdf
BrainSell Technologies
 
Mule Experience Hub and Release Channel with Java 17
Mule Experience Hub and Release Channel with Java 17Mule Experience Hub and Release Channel with Java 17
Mule Experience Hub and Release Channel with Java 17
Bhajan Mehta
 
Use Cases & Benefits of RPA in Manufacturing in 2024.pptx
Use Cases & Benefits of RPA in Manufacturing in 2024.pptxUse Cases & Benefits of RPA in Manufacturing in 2024.pptx
Use Cases & Benefits of RPA in Manufacturing in 2024.pptx
SynapseIndia
 
The Impact of the Internet of Things (IoT) on Smart Homes and Cities
The Impact of the Internet of Things (IoT) on Smart Homes and CitiesThe Impact of the Internet of Things (IoT) on Smart Homes and Cities
The Impact of the Internet of Things (IoT) on Smart Homes and Cities
Arpan Buwa
 
Vulnerability Management: A Comprehensive Overview
Vulnerability Management: A Comprehensive OverviewVulnerability Management: A Comprehensive Overview
Vulnerability Management: A Comprehensive Overview
Steven Carlson
 
Finetuning GenAI For Hacking and Defending
Finetuning GenAI For Hacking and DefendingFinetuning GenAI For Hacking and Defending
Finetuning GenAI For Hacking and Defending
Priyanka Aash
 
MAKE MONEY ONLINE Unlock Your Income Potential Today.pptx
MAKE MONEY ONLINE Unlock Your Income Potential Today.pptxMAKE MONEY ONLINE Unlock Your Income Potential Today.pptx
MAKE MONEY ONLINE Unlock Your Income Potential Today.pptx
janagijoythi
 
Integrating Kafka with MuleSoft 4 and usecase
Integrating Kafka with MuleSoft 4 and usecaseIntegrating Kafka with MuleSoft 4 and usecase
Integrating Kafka with MuleSoft 4 and usecase
shyamraj55
 
leewayhertz.com-AI agents for healthcare Applications benefits and implementa...
leewayhertz.com-AI agents for healthcare Applications benefits and implementa...leewayhertz.com-AI agents for healthcare Applications benefits and implementa...
leewayhertz.com-AI agents for healthcare Applications benefits and implementa...
alexjohnson7307
 
The History of Embeddings & Multimodal Embeddings
The History of Embeddings & Multimodal EmbeddingsThe History of Embeddings & Multimodal Embeddings
The History of Embeddings & Multimodal Embeddings
Zilliz
 
Using LLM Agents with Llama 3, LangGraph and Milvus
Using LLM Agents with Llama 3, LangGraph and MilvusUsing LLM Agents with Llama 3, LangGraph and Milvus
Using LLM Agents with Llama 3, LangGraph and Milvus
Zilliz
 
leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...
leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...
leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...
alexjohnson7307
 
kk vathada _digital transformation frameworks_2024.pdf
kk vathada _digital transformation frameworks_2024.pdfkk vathada _digital transformation frameworks_2024.pdf
kk vathada _digital transformation frameworks_2024.pdf
KIRAN KV
 
Improving Learning Content Efficiency with Reusable Learning Content
Improving Learning Content Efficiency with Reusable Learning ContentImproving Learning Content Efficiency with Reusable Learning Content
Improving Learning Content Efficiency with Reusable Learning Content
Enterprise Knowledge
 
BLOCKCHAIN TECHNOLOGY - Advantages and Disadvantages
BLOCKCHAIN TECHNOLOGY - Advantages and DisadvantagesBLOCKCHAIN TECHNOLOGY - Advantages and Disadvantages
BLOCKCHAIN TECHNOLOGY - Advantages and Disadvantages
SAI KAILASH R
 
Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...
Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...
Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...
bellared2
 
Vertex AI Agent Builder - GDG Alicante - Julio 2024
Vertex AI Agent Builder - GDG Alicante - Julio 2024Vertex AI Agent Builder - GDG Alicante - Julio 2024
Vertex AI Agent Builder - GDG Alicante - Julio 2024
Nicolás Lopéz
 

Recently uploaded (20)

Feature sql server terbaru performance.pptx
Feature sql server terbaru performance.pptxFeature sql server terbaru performance.pptx
Feature sql server terbaru performance.pptx
 
Communications Mining Series - Zero to Hero - Session 3
Communications Mining Series - Zero to Hero - Session 3Communications Mining Series - Zero to Hero - Session 3
Communications Mining Series - Zero to Hero - Session 3
 
Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery
Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery
Girls call Kolkata 👀 XXXXXXXXXXX 👀 Rs.9.5 K Cash Payment With Room Delivery
 
Acumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdf
Acumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdfAcumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdf
Acumatica vs. Sage Intacct vs. NetSuite _ NOW CFO.pdf
 
Mule Experience Hub and Release Channel with Java 17
Mule Experience Hub and Release Channel with Java 17Mule Experience Hub and Release Channel with Java 17
Mule Experience Hub and Release Channel with Java 17
 
Use Cases & Benefits of RPA in Manufacturing in 2024.pptx
Use Cases & Benefits of RPA in Manufacturing in 2024.pptxUse Cases & Benefits of RPA in Manufacturing in 2024.pptx
Use Cases & Benefits of RPA in Manufacturing in 2024.pptx
 
The Impact of the Internet of Things (IoT) on Smart Homes and Cities
The Impact of the Internet of Things (IoT) on Smart Homes and CitiesThe Impact of the Internet of Things (IoT) on Smart Homes and Cities
The Impact of the Internet of Things (IoT) on Smart Homes and Cities
 
Vulnerability Management: A Comprehensive Overview
Vulnerability Management: A Comprehensive OverviewVulnerability Management: A Comprehensive Overview
Vulnerability Management: A Comprehensive Overview
 
Finetuning GenAI For Hacking and Defending
Finetuning GenAI For Hacking and DefendingFinetuning GenAI For Hacking and Defending
Finetuning GenAI For Hacking and Defending
 
MAKE MONEY ONLINE Unlock Your Income Potential Today.pptx
MAKE MONEY ONLINE Unlock Your Income Potential Today.pptxMAKE MONEY ONLINE Unlock Your Income Potential Today.pptx
MAKE MONEY ONLINE Unlock Your Income Potential Today.pptx
 
Integrating Kafka with MuleSoft 4 and usecase
Integrating Kafka with MuleSoft 4 and usecaseIntegrating Kafka with MuleSoft 4 and usecase
Integrating Kafka with MuleSoft 4 and usecase
 
leewayhertz.com-AI agents for healthcare Applications benefits and implementa...
leewayhertz.com-AI agents for healthcare Applications benefits and implementa...leewayhertz.com-AI agents for healthcare Applications benefits and implementa...
leewayhertz.com-AI agents for healthcare Applications benefits and implementa...
 
The History of Embeddings & Multimodal Embeddings
The History of Embeddings & Multimodal EmbeddingsThe History of Embeddings & Multimodal Embeddings
The History of Embeddings & Multimodal Embeddings
 
Using LLM Agents with Llama 3, LangGraph and Milvus
Using LLM Agents with Llama 3, LangGraph and MilvusUsing LLM Agents with Llama 3, LangGraph and Milvus
Using LLM Agents with Llama 3, LangGraph and Milvus
 
leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...
leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...
leewayhertz.com-Generative AI tech stack Frameworks infrastructure models and...
 
kk vathada _digital transformation frameworks_2024.pdf
kk vathada _digital transformation frameworks_2024.pdfkk vathada _digital transformation frameworks_2024.pdf
kk vathada _digital transformation frameworks_2024.pdf
 
Improving Learning Content Efficiency with Reusable Learning Content
Improving Learning Content Efficiency with Reusable Learning ContentImproving Learning Content Efficiency with Reusable Learning Content
Improving Learning Content Efficiency with Reusable Learning Content
 
BLOCKCHAIN TECHNOLOGY - Advantages and Disadvantages
BLOCKCHAIN TECHNOLOGY - Advantages and DisadvantagesBLOCKCHAIN TECHNOLOGY - Advantages and Disadvantages
BLOCKCHAIN TECHNOLOGY - Advantages and Disadvantages
 
Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...
Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...
Russian Girls Call Navi Mumbai 🎈🔥9920725232 🔥💋🎈 Provide Best And Top Girl Ser...
 
Vertex AI Agent Builder - GDG Alicante - Julio 2024
Vertex AI Agent Builder - GDG Alicante - Julio 2024Vertex AI Agent Builder - GDG Alicante - Julio 2024
Vertex AI Agent Builder - GDG Alicante - Julio 2024
 

Deep C

  • 1. 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
  • 4. 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:
  • 5. 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); }
  • 6. 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); } What will happen if you try to compile, link and run this program?
  • 7. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); }
  • 8. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } One candidate might say:
  • 9. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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.
  • 10. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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...
  • 11. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); }
  • 12. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } But another candidate might use this as an opportunity to start demonstrating a deeper understanding. She might say things like:
  • 13. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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.
  • 14. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } and then she elaborates a bit by saying:
  • 15. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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:
  • 16. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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: However a proper C compiler will create an implicit declaration for the function printf(), compile this code into an object file.
  • 17. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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: However a proper C compiler will create an implicit declaration for the function printf(), compile this code into an object file. And when linked with a standard library, it will find a definition of printf()that accidentally will match the implicit declaration.
  • 18. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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: However a proper C compiler will create an implicit declaration for the function printf(), compile this code into an object file. And when linked with a standard library, it will find a definition of printf()that accidentally will match the implicit declaration. So the program above will actually compile, link and run.
  • 19. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } 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: However a proper C compiler will create an implicit declaration for the function printf(), compile this code into an object file. And when linked with a standard library, it will find a definition of printf()that accidentally will match the implicit declaration. So the program above will actually compile, link and run. You might get a warning though.
  • 20. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } and while she is on the roll, she might continue with:
  • 21. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } and while she is on the roll, she might continue with: If this is C99, the exit value is defined 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 undefined garbage value.
  • 22. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } and while she is on the roll, she might continue with: If this is C99, the exit value is defined 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 undefined 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.
  • 23. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } and while she is on the roll, she might continue with:
  • 24. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); } and while she is on the roll, she might continue with: 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 definitions does not hurt.
  • 25. What will happen if you try to compile, link and run this program? int main() { int a = 42; printf(“%dn”, a); }
  • 26. What will happen if you try to compile, link and run this program? int main(void) { int a = 42; printf(“%dn”, a); }
  • 27. What will happen if you try to compile, link and run this program? int main(void) { int a = 42; printf(“%dn”, a); } 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.
  • 28. What will happen if you try to compile, link and run this program? int main(void) { int a = 42; printf(“%dn”, a); }
  • 29. What will happen if you try to compile, link and run this program? int main(void) { int a = 42; printf(“%dn”, a); }
  • 30. What will happen if you try to compile, link and run this program? int main(void) { int a = 42; printf(“%dn”, a); } ah, remember to include an explicit declaration of printf() as well
  • 31. What will happen if you try to compile, link and run this program? int main(void) { int a = 42; printf(“%dn”, a); }
  • 32. What will happen if you try to compile, link and run this program? int main(void) { int a = 42; printf(“%dn”, a); }
  • 33. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); }
  • 34. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } now, this is a darn cute little C program! Isn’t it?
  • 35. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine:
  • 36. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c
  • 37. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc foo.o
  • 38. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc foo.o $ ./a.out
  • 39. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc foo.o $ ./a.out 42
  • 40. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc foo.o $ ./a.out 42 $ echo $?
  • 41. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc foo.o $ ./a.out 42 $ echo $? 3
  • 42. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc -std=c99 -c foo.c $ cc foo.o $ ./a.out 42 $ echo $? 3
  • 43. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc -std=c99 -c foo.c $ cc foo.o $ cc foo.o $ ./a.out 42 $ echo $? 3
  • 44. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc -std=c99 -c foo.c $ cc foo.o $ cc foo.o $ ./a.out $ ./a.out 42 $ echo $? 3
  • 45. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc -std=c99 -c foo.c $ cc foo.o $ cc foo.o $ ./a.out $ ./a.out 42 42 $ echo $? 3
  • 46. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc -std=c99 -c foo.c $ cc foo.o $ cc foo.o $ ./a.out $ ./a.out 42 42 $ echo $? $ echo $? 3
  • 47. What will happen if you try to compile, link and run this program? #include <stdio.h> int main(void) { int a = 42; printf(“%dn”, a); } and here is what I get when compiling, linking and running the above program on my machine: $ cc -std=c89 -c foo.c $ cc -std=c99 -c foo.c $ cc foo.o $ cc foo.o $ ./a.out $ ./a.out 42 42 $ echo $? $ echo $? 3 0
  • 48. Is there any difference between these two candidates?
  • 49. Is there any difference between these two candidates? Not much, yet, but I really like her answers so far.
  • 50. Now suppose they are not really candidates. Perhaps they are stereotypes for engineers working in your organization?
  • 51. Now suppose they are not really candidates. Perhaps they are stereotypes for engineers working in your organization?
  • 52. 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?
  • 53. Let’s find out how deep their knowledge of C and C++ is...
  • 54. Let’s find out how deep their knowledge of C and C++ is...
  • 55. #include <stdio.h> void foo(void) { int a = 3; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 56. #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(); }
  • 57. #include <stdio.h> void foo(void) { int a = 3; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 58. #include <stdio.h> void foo(void) { static int a = 3; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 59. #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(); }
  • 60. #include <stdio.h> void foo(void) { static int a = 3; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 61. #include <stdio.h> void foo(void) { static int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 62. #include <stdio.h> void foo(void) { static int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 63. #include <stdio.h> void foo(void) { static int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 64. #include <stdio.h> eh, is it undefined? do you get garbage values? void foo(void) { static int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 65. #include <stdio.h> eh, is it undefined? do you get garbage values? void foo(void) No, you get 1, then 2, then 3 { static int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 66. #include <stdio.h> eh, is it undefined? do you get garbage values? void foo(void) No, you get 1, then 2, then 3 { static int a; ++a; ok, I see... why? printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 67. #include <stdio.h> eh, is it undefined? do you get garbage values? void foo(void) No, you get 1, then 2, then 3 { static int a; ++a; ok, I see... why? printf("%dn", a); } because static variables are set to 0 int main(void) { foo(); foo(); foo(); }
  • 68. #include <stdio.h> eh, is it undefined? do you get garbage values? void foo(void) No, you get 1, then 2, then 3 { static int a; ++a; ok, I see... why? printf("%dn", a); } because static variables are set to 0 int main(void) { foo(); foo(); foo(); }
  • 69. #include <stdio.h> eh, is it undefined? do you get garbage values? void foo(void) No, you get 1, then 2, then 3 { static int a; ++a; ok, I see... why? 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 }
  • 70. #include <stdio.h> void foo(void) { static int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 71. #include <stdio.h> void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 72. #include <stdio.h> void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 73. #include <stdio.h> void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 74. 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(); }
  • 75. Now you get 1, then 1, then 1 #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(); }
  • 76. Now you get 1, then 1, then 1 #include <stdio.h> Ehm, why do you think that will happen? void foo(void) { Because you said they where initialized to 0 int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 77. Now you get 1, then 1, then 1 #include <stdio.h> Ehm, why do you think that will happen? void foo(void) { Because you said they where initialized to 0 int a; ++a; But this is not a static variable printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 78. Now you get 1, then 1, then 1 #include <stdio.h> Ehm, why do you think that will happen? void foo(void) { Because you said they where initialized to 0 int a; ++a; But this is not a static variable printf("%dn", a); } ah, then you get three garbage values int main(void) { foo(); foo(); foo(); }
  • 79. Now you get 1, then 1, then 1 #include <stdio.h> Ehm, why do you think that will happen? void foo(void) { Because you said they where initialized to 0 int a; ++a; But this is not a static variable printf("%dn", a); } ah, then you get three garbage values int main(void) { foo(); foo(); foo(); }
  • 80. Now you get 1, then 1, then 1 #include <stdio.h> Ehm, why do you think that will happen? void foo(void) { Because you said they where initialized to 0 int a; ++a; But this is not a static variable printf("%dn", a); } ah, then you get three garbage values int main(void) the value of a will be undefinded, 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.
  • 81. Now you get 1, then 1, then 1 #include <stdio.h> Ehm, why do you think that will happen? void foo(void) { Because you said they where initialized to 0 int a; ++a; But this is not a static variable printf("%dn", a); } ah, then you get three garbage values int main(void) the value of a will be undefinded, 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. on my machine I actually get, 1, then 2, then 3
  • 82. Now you get 1, then 1, then 1 #include <stdio.h> Ehm, why do you think that will happen? void foo(void) { Because you said they where initialized to 0 int a; ++a; But this is not a static variable printf("%dn", a); } ah, then you get three garbage values int main(void) the value of a will be undefinded, 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. 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
  • 83. #include <stdio.h> void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 84. #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(); }
  • 85. #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(); }
  • 86. #include <stdio.h> Why do you think static variables are set to 0, while auto variables are not initialized? void foo(void) { int a; eh? ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 87. #include <stdio.h> Why do you think static variables are set to 0, while auto variables are not initialized? void foo(void) { int a; eh? ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 88. #include <stdio.h> Why do you think static variables are set to 0, while auto variables are not initialized? 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(); }
  • 89. #include <stdio.h> Why do you think static variables are set to 0, while auto variables are not initialized? 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(); 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.
  • 90. #include <stdio.h> Why do you think static variables are set to 0, while auto variables are not initialized? 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(); 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.
  • 91. #include <stdio.h> void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 92. #include <stdio.h> void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 93. #include <stdio.h> void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 94. #include <stdio.h> static int a; void foo(void) { int a; ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 95. #include <stdio.h> static int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 96. #include <stdio.h> static int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 97. #include <stdio.h> static int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 98. #include <stdio.h> static int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 99. 1, 2, 3 #include <stdio.h> static int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 100. 1, 2, 3 #include <stdio.h> ok, why? static int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 101. 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(); }
  • 102. 1, 2, 3 #include <stdio.h> ok, why? static int a; because a is static, and therefore initialized to 0 void foo(void) { I agree... ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 103. 1, 2, 3 #include <stdio.h> ok, why? static int a; because a is static, and therefore initialized to 0 void foo(void) { I agree... ++a; printf("%dn", a); cool! } int main(void) { foo(); foo(); foo(); }
  • 104. #include <stdio.h> static int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 105. #include <stdio.h> int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 106. #include <stdio.h> int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 107. #include <stdio.h> int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 108. garbage, garbage, garbage #include <stdio.h> int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 109. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 110. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; oh, is it still initialized to 0? void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 111. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; oh, is it still initialized to 0? void foo(void) { yes ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 112. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; oh, is it still initialized to 0? void foo(void) { yes ++a; printf("%dn", a); maybe it will print 1, 2, 3? } int main(void) { foo(); foo(); foo(); }
  • 113. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; oh, is it still initialized to 0? void foo(void) { yes ++a; printf("%dn", a); maybe it will print 1, 2, 3? } yes int main(void) { foo(); foo(); foo(); }
  • 114. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; oh, is it still initialized to 0? void foo(void) { yes ++a; printf("%dn", a); maybe it will print 1, 2, 3? } 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(); }
  • 115. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; oh, is it still initialized to 0? void foo(void) { yes ++a; printf("%dn", a); maybe it will print 1, 2, 3? } 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(); } not really, or wait a minute, it has do with private variables and public variables.
  • 116. garbage, garbage, garbage #include <stdio.h> why do you think that? int a; oh, is it still initialized to 0? void foo(void) { yes ++a; printf("%dn", a); maybe it will print 1, 2, 3? } 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(); } not really, or wait a minute, it has do with private variables and public variables. yeah, something like that...
  • 117. #include <stdio.h> int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 118. #include <stdio.h> int a; void foo(void) { ++a; printf("%dn", a); } int main(void) { foo(); foo(); foo(); }
  • 119. 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(); }
  • 120. 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) 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(); }
  • 121. 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) 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 file 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.
  • 123. I am now going to show you something cool!
  • 124. 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(); }
  • 125. I am now going to show you something cool! #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(); }
  • 126. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 42 void foo(void) { int a; printf("%dn", a); } void bar(void) { int a = 42; } int main(void) { bar(); foo(); }
  • 127. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 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(); }
  • 128. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 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(); }
  • 129. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 42 void foo(void) { Can you explain this behaviour? int a; printf("%dn", a); } eh? void bar(void) { int a = 42; } int main(void) { bar(); foo(); }
  • 130. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 42 void foo(void) { Can you explain this behaviour? 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. }
  • 131. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 42 void foo(void) { Can you explain this behaviour? 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...
  • 132. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 42 void foo(void) { int a; printf("%dn", a); } void bar(void) { int a = 42; } int main(void) { bar(); foo(); }
  • 133. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 42 void foo(void) { int a; printf("%dn", a); } void bar(void) { int a = 42; } int main(void) { bar(); foo(); }
  • 134. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 42 void foo(void) { Nice! I love it! int a; printf("%dn", a); } void bar(void) { int a = 42; } int main(void) { bar(); foo(); }
  • 135. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 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(); }
  • 136. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 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) 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(); }
  • 137. I am now going to show you something cool! #include <stdio.h> $ cc foo.c && ./a.out 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) 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 file wants to link with the function). Anyway, I suspect the value printed will be something else if you optimize the code.
  • 138. #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(); }
  • 139. #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(); }
  • 140. #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(); }
  • 141. So what about this code snippet?
  • 142. So what about this code snippet? #include <stdio.h> void foo(void) { int a = 41; a = a++; printf("%dn", a); } int main(void) { foo(); }
  • 143. #include <stdio.h> void foo(void) { int a = 41; a = a++; printf("%dn", a); } int main(void) { foo(); }
  • 144. #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(); }
  • 145. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; printf("%dn", a); } int main(void) { foo(); }
  • 146. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; But I think the answer is 42 printf("%dn", a); } int main(void) { foo(); }
  • 147. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; But I think the answer is 42 printf("%dn", a); } Why do you think that? int main(void) { foo(); }
  • 148. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; But I think the answer is 42 printf("%dn", a); } Why do you think that? int main(void) Because what else can it be? { foo(); }
  • 149. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; But I think the answer is 42 printf("%dn", a); } Why do you think that? int main(void) Because what else can it be? { foo(); Indeed, 42 is exactly what I get when I } run this on my machine
  • 150. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; But I think the answer is 42 printf("%dn", a); } Why do you think that? int main(void) Because what else can it be? { foo(); Indeed, 42 is exactly what I get when I } run this on my machine hey, you see!
  • 151. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; But I think the answer is 42 printf("%dn", a); } Why do you think that? int main(void) Because what else can it be? { foo(); Indeed, 42 is exactly what I get when I } run this on my machine hey, you see! But the code is actually undefined.
  • 152. #include <stdio.h> I would never write code like that. void foo(void) That’s nice to hear! { int a = 41; a = a++; But I think the answer is 42 printf("%dn", a); } Why do you think that? int main(void) Because what else can it be? { foo(); Indeed, 42 is exactly what I get when I } run this on my machine hey, you see! But the code is actually undefined. Yeah, I told you - I never write code like that
  • 153. #include <stdio.h> void foo(void) { int a = 41; a = a++; printf("%dn", a); } int main(void) { foo(); }
  • 154. #include <stdio.h> void foo(void) { int a = 41; a = a++; printf("%dn", a); } int main(void) { foo(); }
  • 155. #include <stdio.h> a gets an undefined value void foo(void) { int a = 41; a = a++; printf("%dn", a); } int main(void) { foo(); }
  • 156. #include <stdio.h> a gets an undefined value 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(); }
  • 157. #include <stdio.h> a gets an undefined value 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); Then you must increase the warning level, } the value of a is certainly undefined 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 undefined.
  • 158. #include <stdio.h> a gets an undefined value 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); Then you must increase the warning level, } the value of a is certainly undefined 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 undefined. So you say a can be whatever? But I do get 42
  • 159. #include <stdio.h> a gets an undefined value 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); Then you must increase the warning level, } the value of a is certainly undefined 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 undefined. 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 undefined ;-)
  • 160. So what about this code snippet?
  • 161. So what about this code snippet? #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); }
  • 162. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); }
  • 163. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } Easy, it prints 3, 4 and then 7
  • 164. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } Easy, it prints 3, 4 and then 7 Actually, this could also be 4, 3 and then 7
  • 165. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } Easy, it prints 3, 4 and then 7 Actually, this could also be 4, 3 and then 7 Huh? Is the evaluation order undefined?
  • 166. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } Easy, it prints 3, 4 and then 7 Actually, this could also be 4, 3 and then 7 Huh? Is the evaluation order undefined? It is not really undefined, it is unspecified
  • 167. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } Easy, it prints 3, 4 and then 7 Actually, this could also be 4, 3 and then 7 Huh? Is the evaluation order undefined? It is not really undefined, it is unspecified Well, whatever. Lousy compilers. I think it should give us a warning?
  • 168. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } Easy, it prints 3, 4 and then 7 Actually, this could also be 4, 3 and then 7 Huh? Is the evaluation order undefined? It is not really undefined, it is unspecified Well, whatever. Lousy compilers. I think it should give us a warning? A warning about what?
  • 169. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); }
  • 170. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); }
  • 171. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } The evaluation order of most expressions in C and C++ are unspecified, 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.
  • 172. #include <stdio.h> int b(void) { puts(“3”); return 3; } int c(void) { puts(“4”); return 4; } int main(void) { int a = b() + c(); printf(“%dn”, a); } The evaluation order of most expressions in C and C++ are unspecified, 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
  • 174. At this point I think he has just revealed a shallow understanding of C programming, while she has excelled in her answers so far.
  • 175. So what is it that she seems to understand better than most?
  • 176. So what is it that she seems to understand better than most? • Declaration and Definition
  • 177. So what is it that she seems to understand better than most? • Declaration and Definition • Calling conventions and activation frames
  • 178. So what is it that she seems to understand better than most? • Declaration and Definition • Calling conventions and activation frames • Sequence points
  • 179. So what is it that she seems to understand better than most? • Declaration and Definition • Calling conventions and activation frames • Sequence points • Memory model
  • 180. So what is it that she seems to understand better than most? • Declaration and Definition • Calling conventions and activation frames • Sequence points • Memory model • Optimization
  • 181. So what is it that she seems to understand better than most? • Declaration and Definition • Calling conventions and activation frames • Sequence points • Memory model • Optimization • Knowledge of different C standards
  • 182. We’d like to share some things about: Sequence points Different C standards
  • 183. What do these code snippets print?
  • 184. What do these code snippets print? 1 int a=41; a++; printf("%dn", a);
  • 185. What do these code snippets print? 1 int a=41; a++; printf("%dn", a); 2 int a=41; a++ & printf("%dn", a);
  • 186. 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);
  • 187. 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); 4 int a=41; if (a++ < 42) printf("%dn", a);
  • 188. 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); 4 int a=41; if (a++ < 42) printf("%dn", a); 5 int a=41; a = a++; printf("%dn", a);
  • 189. What do these code snippets print? 1 int a=41; a++; printf("%dn", a); 42 2 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); 5 int a=41; a = a++; printf("%dn", a);
  • 190. What do these code snippets print? 1 int a=41; a++; printf("%dn", a); 42 2 int a=41; a++ & printf("%dn", a); undefined 3 int a=41; a++ && printf("%dn", a); 4 int a=41; if (a++ < 42) printf("%dn", a); 5 int a=41; a = a++; printf("%dn", a);
  • 191. What do these code snippets print? 1 int a=41; a++; printf("%dn", a); 42 2 int a=41; a++ & printf("%dn", a); undefined 3 int a=41; a++ && printf("%dn", a); 42 4 int a=41; if (a++ < 42) printf("%dn", a); 5 int a=41; a = a++; printf("%dn", a);
  • 192. What do these code snippets print? 1 int a=41; a++; printf("%dn", a); 42 2 int a=41; a++ & printf("%dn", a); undefined 3 int a=41; a++ && printf("%dn", a); 42 4 int a=41; if (a++ < 42) printf("%dn", a); 42 5 int a=41; a = a++; printf("%dn", a);
  • 193. What do these code snippets print? 1 int a=41; a++; printf("%dn", a); 42 2 int a=41; a++ & printf("%dn", a); undefined 3 int a=41; a++ && printf("%dn", a); 42 4 int a=41; if (a++ < 42) printf("%dn", a); 42 5 int a=41; a = a++; printf("%dn", a); undefined
  • 194. What do these code snippets print? 1 int a=41; a++; printf("%dn", a); 42 2 int a=41; a++ & printf("%dn", a); undefined 3 int a=41; a++ && printf("%dn", a); 42 4 int a=41; if (a++ < 42) printf("%dn", a); 42 5 int a=41; a = a++; printf("%dn", a); undefined When exactly do side-effects take place in C and C++?
  • 195. 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)
  • 196. 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!
  • 197. 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!!
  • 198. Sequence Points A lot of developers think C has many sequence points
  • 199. Sequence Points The reality is that C has very few sequence points. This helps to maximize optimization opportunities for the compiler.
  • 200. /* 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); }
  • 201. Let’s get back to our two developers...
  • 202. So what about this code snippet?
  • 203. So what about this code snippet? #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)); }
  • 204. #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)); }
  • 205. #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)); } It will print 4, 1 and 12
  • 206. #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)); } It will print 4, 1 and 12 Indeed, it is exactly what I get on my machine
  • 207. #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)); } It will print 4, 1 and 12 Indeed, it is exactly what I get on my machine 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
  • 208. #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)); } It will print 4, 1 and 12 Indeed, it is exactly what I get on my machine 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 ok
  • 209. #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)); } It will print 4, 1 and 12 Indeed, it is exactly what I get on my machine 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 ok do you want another ice cream?
  • 210. #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)); }
  • 211. #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)); }
  • 212. #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)); } 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
  • 213. #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)); } 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 ok, what should specifier should we use?
  • 214. #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)); } 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 ok, what should specifier should we use? 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 specifier for printing size_t values, so %zu might be an option.
  • 215. #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)); } 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 ok, what should specifier should we use? 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 specifier for printing size_t values, so %zu might be an option. ok, let’s fix the printf issue, and then you can try to answer the question
  • 216. #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)); }
  • 217. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); }
  • 218. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 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?
  • 219. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 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? Yes, I have a 64-bit machine running in 32-bit compatibility mode.
  • 220. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 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? Yes, I have a 64-bit machine running in 32-bit compatibility mode. Then I would like to guess that this prints 4, 1, 12 due to word alignment
  • 221. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 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? Yes, I have a 64-bit machine running in 32-bit compatibility mode. 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 flags. It could be 4, 1, 9 if you ask the compiler to pack the structs, eg -fpack-struct in gcc.
  • 222. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); }
  • 223. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 4, 1, 12 is indeed what I get on my machine. Why 12?
  • 224. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 4, 1, 12 is indeed what I get on my machine. Why 12? 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.
  • 225. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 4, 1, 12 is indeed what I get on my machine. Why 12? 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. Why is it expensive to work on values that are not aligned?
  • 226. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } 4, 1, 12 is indeed what I get on my machine. Why 12? 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. 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.
  • 227. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); }
  • 228. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } so what if I add a char d to the struct?
  • 229. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } so what if I add a char d to the struct? 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 first of all because 13 would be a not so efficient 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.
  • 230. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } so what if I add a char d to the struct? 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 first of all because 13 would be a not so efficient 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. So why doesn’t the compiler reorder the members in the structure to optimize memory usage, and execution speed?
  • 231. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } so what if I add a char d to the struct? 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 first of all because 13 would be a not so efficient 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. 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.
  • 232. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); }
  • 233. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } so what if I add a char * d to the end of the struct?
  • 234. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } so what if I add a char * d to the end of the struct? 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 efficiency? Maybe this code will print 4,1,24?
  • 235. #include <stdio.h> struct X { int a; char b; int c; }; int main(void) { printf("%zun", sizeof(int)); printf("%zun", sizeof(char)); printf("%zun", sizeof(struct X)); } so what if I add a char * d to the end of the struct? 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 efficiency? 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.
  • 236. So what is it that she seems to understand better than most?
  • 237. So what is it that she seems to understand better than most? • Some experience with 32-bit vs 64-bit issues
  • 238. So what is it that she seems to understand better than most? • Some experience with 32-bit vs 64-bit issues • Memory alignment
  • 239. So what is it that she seems to understand better than most? • Some experience with 32-bit vs 64-bit issues • Memory alignment • CPU and memory optimization
  • 240. So what is it that she seems to understand better than most? • Some experience with 32-bit vs 64-bit issues • Memory alignment • CPU and memory optimization • Spirit of C
  • 241. We’d like to share some things about: Memory model Optimization The spirit of C
  • 242. 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; }
  • 243. 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; }
  • 244. 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; }