C Basics 1
Computer Organization ICS@VT ©2005-2019 WD McQuain
A History Lesson
Development of language by Dennis Ritchie at Bell Labs culminated in the C language
in 1972.
Motivation was to facilitate development of systems software, especially OS
development.
Traditionally, supports a procedural view of problem analysis.
Formal language Standard adopted in 1990; required compromises because of vast body
of existing C code based on a more-or-less common understanding of the language.
Significant revision, ISO/IEC 9899:1999 or simply C99 if you like, was adopted in 1999;
another revision ISO/IEC 9899:2011 or C11 was adopted in 2011.
My presentation will be based on the C11 Standard, although the C99 Standard covers
everything we will use.
A final draft of the current standard is available at:
http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
C Basics 2
Computer Organization ICS@VT ©2005-2019 WD McQuain
The First Program
#include <stdio.h> // load declarations of std
// library functions for I/O
int main() { // mandatory fn
printf("Hello, world!\n"); // output to console
return 0; // exit fn (& pgm)
}
Since tradition demands it:
Note: #include loads declarations from standard C library (and more)
Every C program must have a non-member function called main().
main() must be declared with a return type of int.
C Basics 3
Computer Organization ICS@VT ©2005-2019 WD McQuain
The Preprocessor
When a C compiler is invoked, the first thing that happens is that the code is parsed and
modified by a preprocessor.
The preprocessor handles a collection of commands (commonly called directives), which
are denoted by the character '#'.
#include directives specify an external file (for now a C library file); the preprocessor
essentially copies the contents of the specified file in place of the directive.
We will see more interesting preprocessor directives later.
#include <stdio.h>
. . .
int main() {
printf("Hello, world!\n");
return 0;
}
Contents of file stdio.h are copied here.
C Basics 4
Computer Organization ICS@VT ©2005-2019 WD McQuain
The C Standard Library
The C Standard Library includes a fairly large collection of types and functions.
The declarations of these are placed into a collection of header files, which are part of
the distribution of every C compiler.
The implementations are placed into a collection of C source files, which are then pre-
compiled into binary library files (also part of every C compiler distribution).
C programmers incorporate portions of the Standard Library into their programs by making use of #include directives.
C Basics 5
Computer Organization ICS@VT ©2005-2019 WD McQuain
What's the Same as Java (more or less)
Naming rules are the same. But… customary conventions differ.
Declaration syntax is the same.
Scoping rules are similar, within a file at least.
Many reserved words are the same, with the same meanings, but ALL (almost) reserved
words in C and ALL (almost) Standard Library identifiers are purely lower-case.
Operator symbols and expressions are generally the same.
The basic control structures (if, for, while, . . .) have same syntax and semantics.
Function call/return syntax and semantics are the same; as with Java, function parameters
can only be passed into a function by value.
C Basics 6
Computer Organization ICS@VT ©2005-2019 WD McQuain
Conditionals and Loops
C includes the same set of conditional and loop statement forms as Java:
if…
if…else…
switch…
while…
for…
do…while…
C also has a goto statement for unconditional branching.
Thou shalt not goto.
C Basics 7
Computer Organization ICS@VT ©2005-2019 WD McQuain
C Philosophy
The stated goal of the designers of the C language is:
Correct code should execute as fast as possible on the underlying hardware.
Of course, good programmers write only correct code…
… and only good programmers should be writing code.
C Basics 8
Computer Organization ICS@VT ©2005-2019 WD McQuain
All built-in C types are primitives; there are no class types in the language.
Core Differences vs Java
In C there is no notion of a member function.
A C program is a collection of functions that call one another, not a collection of classes
and objects that use one another's services.
In C, every variable may be allocated dynamically, or not; it's up to you to decide.
Scope rules are slightly different; a name declared within a block is strictly local to the
block.
In most cases, C variables are not automatically initialized at all; you may initialize them
yourself when you declare them.
C Basics 9
Computer Organization ICS@VT ©2005-2019 WD McQuain
Variable Declarations
All declared objects are (by default) statically allocated (not dynamically). Thus, the following declaration results in X and Y being objects of type int, not references to
objects:
int X = 6,
Y = 28;
This has many consequences:
- assigning X to Y does not result in an alias;
rather X becomes a copy of Y, but is still an
entirely different object; just like Java
primitives, and unlike Java objects
- using X as a parameter to a function does
not allow the function to modify X
- logically, you can only initialize declared
objects to 0 if they are numeric types
Memory
X 6
Y 28
Memory
X 6
Y 6
C Basics 10
Computer Organization ICS@VT ©2005-2019 WD McQuain
Automatic Variable Initialization
Variables are not (usually) automatically initialized.
The compiler will not check for use of a variable before it has been initialized.
int X, Y;
Y = 2*X + 1;
This is a common source of errors in C programs and is easily avoided.
Memory
X ??
Y ????
Note:
- when Linux allocates memory to a process, it may write zeros into that memory,
which has the effect of initializing variables stored within that memory to 0; you
should never count on that to save you.
- static globals (explained later) are initialized to 0 if you do not initialize them
C Basics 11
Computer Organization ICS@VT ©2005-2019 WD McQuain
Boolean Variables
C initially did not have a Boolean type.
Integer values can be used as Booleans; zero is interpreted as false and all other values are
interpreted as true.
Modern C includes a _Bool type which is aliased to bool.
Every expression in C has a value (well-defined or not). Hence, the following is valid
code:
if ( x = 42 )
// always executes the if-clause
C Basics 12
Computer Organization ICS@VT ©2005-2019 WD McQuain
C Primitive Types
Standard C provides a plethora of primitive types. These store single values, and are most
definitely not objects in the Java sense. In particular, there is no guarantee of automatic
initialization.
Integer types Probable characteristics
int 32-bits
unsigned int 32-bits
short (int) 16-bits
unsigned short (int) 16-bits
long (int) 32-bits
unsigned long (int) 32-bits
Floating-point types Conforming implementations provide:
float 32-bit IEEE single-precision type
double 64-bit IEEE double-precision type
#include <stdint.h>
int8_t uint8_t
int16_t uint16_t
int32_t uint32_t
int64_t uint64_t
C Basics 13
Computer Organization ICS@VT ©2005-2019 WD McQuain
Ranges of C Primitive Integer Types
For integer types, the range of representation depends on the number of bits used, and
whether the type is signed or unsigned:
type min max
int8_t -128 127
uint8_t 0 255
int16_t -32,768 32,767
uint16_t 0 65,355
int32_t -2,147,483,648 2,147,483,647
uint32_t 0 4,294,967,295
int64_t -9,223,372,036,854,775,808 9,223,372,036,854,775,807
uint64_t 0 18,446,744,073,709,551,615
The choice matters:
- too narrow and you risk numeric overflow and incorrect results
- unnecessarily wide and you use more memory than is logically needed
C Basics 14
Computer Organization ICS@VT ©2005-2019 WD McQuain
C Primitive Types
Character types Probable characteristics
char 1-byte, ASCII code
unsigned char 1-byte, unsigned integer
Logical types Probable characteristics
bool 1-byte, value either true or false
<stdbool.h>
(really _Bool, but standard macro provides alias)
The primitive types, except as noted, are all available without any inclusions from the
Standard Library.
C Basics 15
Computer Organization ICS@VT ©2005-2019 WD McQuain
Same syntax as Java.
Semantics are generally the same as well, although the C Standard leaves the result of a
number of unwise constructs undefined.
For example:
int x = 5;
x = x++ * x++;
Now, the C Standard leaves the result of executing that statement undefined. If you want
a very detailed and interesting discussion of why this is so, take a look at:
http://c-faq.com/~scs/readings/undef.950321.html
My take on the issue is that such expressions are generally "stupid" and unlikely to be
used in real code…
C Arithmetic Operators
Precedence rules are the same as Java.
Precedence can be forced (and disambiguated) by use of parentheses.
C Basics 16
Computer Organization ICS@VT ©2005-2019 WD McQuain
Creating User-defined Types
public class Rational {
private int top;
private int bottom;
public Rational(...) {
...
}
...
}
Java C
struct _Rational {
int top;
int bottom;
};
typedef struct _Rational Rational;
Rational Rational_Create(...) {
...
}
...
Classes:
- data and function members
- member access control enforced by
compiler
- automatic initialization
(constructor must be invoked when
object is created)
struct types:
- data members only
- member access control enforced by
programmer discipline (or not)
- initialization only if programmer
remembers to do it
C Basics 17
Computer Organization ICS@VT ©2005-2019 WD McQuain
Code Organization for User-defined Type
// Function definitions go
// inside the body of the
// class definition.
// The code for the type goes
// into a single file.
public class Rational {
private int top;
private int bottom;
public Rational(...) {
. . .
}
. . .
}
Java C
// Type definition typically goes
// in a header file (Rational.h).
struct _Rational {
int top;
int bottom;
};
typedef struct _Rational Rational;
. . .
// Function definitions typically
// go in a C file (Rational.c).
Rational Rational_Create(...) {
. . .
}
. . .
A collection of related functions (and types)
is called a module.
C Basics 18
Computer Organization ICS@VT ©2005-2019 WD McQuain
Function Interfaces for User-defined Types
C
// No notion of a member function.
Rational Rational_Create(int top, int bottom) {
. . .
}
// So objects the function will "work on" must be passed
// to the function via parameters.
Rational Rational_Add(Rational left, Rational right) {
. . .
}
. . .
C Basics 19
Computer Organization ICS@VT ©2005-2019 WD McQuain
Memory Management
In C, objects which are allocated dynamically are not automatically deallocated (at least,
not until the program terminates execution).
Deallocating them efficiently is the responsibility of the programmer.
For now, we’ll examine one simple case to illustrate the difference.
C Basics 20
Computer Organization ICS@VT ©2005-2019 WD McQuain
Object Creation
public class Rational {
...
public Rational(...) {
...
}
...
}
// MUST alloc dynamically
// (exception: primitives)
Rational r1 = new Rational(...);
struct _Rational {
int top;
int bottom;
};
typedef struct _Rational Rational;
...
// CAN alloc statically
Rational R1;
// OR alloc dynamically
Rational* R1 = malloc(sizeof(Rational));
Java C
C Basics 21
Computer Organization ICS@VT ©2005-2019 WD McQuain
Dynamic vs Static Allocation
Dynamic allocation
- memory for object is requested by explicit call in code, executed at runtime
- decision whether to actually create object can be deferred until runtime
- requires call to OS function; may be slow; request may be denied
- raises issue of disposing of the memory once object is no longer needed
Static allocation
- memory for object is requested by presence of an object declaration in code
- decision whether to create object is made when code is written
- memory allocation is automatic; only denied if program is out of memory
- disposing of the memory is handled automatically; no burden on the programmer
C Basics 22
Computer Organization ICS@VT ©2005-2019 WD McQuain
Aside: Pointer Variables
A pointer is simply a variable whose value is the address of something.
When we allocate an object dynamically, we get an address:
Rational r1 = new Rational(...);
In the Java fragment above, r1 is a reference variable, which is a kind of pointer, and the
operator new returns the address of a chunk of memory which will hold the object being
allocated.
In C, pointer variables are declared by using some "syntactic sugar" after the type
specifier:
Rational* r1 = malloc(...);
The symbol '*' after the type specifier means that r1 is a pointer.
The C function malloc() returns the address of a chunk of memory which will hold the
object being allocated.
Java
C