C Programming Language

int main(void)

"main" is special. Your program begins executing at the beginning of main. This means that every program must have a main somewhere.

Difference between: int a[10][20]; and int *b[10]; when referencing a[3][4] or b[3][4].

'a' is a true two-dimensional array: 200 int-sized locations have been set aside. For 'b', the definition only allocates 10 pointers and does not initialize them; initialization must be done explicitly, either statically or with code. - Assuming that each element of b does point to a 20 element array, then there will be 200 int set aside, plus 10 cells for the pointers.

Difference between an array name and a pointer?

1. A pointer is a variable, so 'pa = a' and 'pa++' are legal. 2. An array name is not a variable; constructions like 'a = pa' and 'a++' are illegal.

int a[10];

1. Defines an array 'a' or size 10 2. A block of 10 consecutive objects named a[0], a[1], ... , a[9]

External, Static, and Automatic Variable Default Initialization

1. External Variables - Initialized to zero by default 2. Static Variables - Initialized to Zero by default 3. Automatic Variables - Undefined Values (garbage values) by default

while (condition) { statements; } while loop

1. The condition in parentheses is tested. 2. If it is true, the body of the loop is executed. 3. Then the condition is re-tested and if true, the body is executed again. 4. When the test becomes false the loop ends, and execution continues at the statement that follows the loop.

int *pa; pa = &a[0];

1. pa is a pointer to an integer 2. pa set to point to element zero of a (pa contains the address of a[0])

header file

A centralized file that contains the definitions and declarations shared among files. Included by using #include at the front of each source file.

'c'

A character written between single quotes represents an integer value equal to the numerical value of the character in the machine's character set. It is called a character constant.

Optional Flag or Parameter

A common convention for C programs on UNIX systems is that an argument that begins with a minus sign (-) introduces an optional flag or parameter.

Function Prototype

A declaration of a function that specifies the function's name and type signature but omits the function body.

void *

A generic pointer to void. It is used to hold any type of pointer but cannot dereference itself.

printf("hello, world\n")

A library function that prints output, in this case the string of characters between the quotes.

Switch Statement

A multi-way decision that tests whether an expression matches one of a number of constant integer value and branches accordingly. 1. Each case is labeled by one of more integer-valued constants. 2. If a case matches the expression value, execution starts at the case. All case expressions must be different. 3. The case labeled default is executed is executed if none of the other cases are satisfied. 4. Cases and the default can occur in any order. P.S. - After the code for one case is done, execution falls through to the next unless you leave the switch with 'break' or 'return'.

'\0' in an Array

A null character ('\0') is put at the end of an array to mark the end of the string of characters.

Pointer Arithmetic

A pointer in C is an address, which is a numeric value. Therefore, you can perform arithmetic operations on a pointer just as you can on a numeric value. - There are four arithmetic operators that can be used on pointers: ++, --, +, and -

"hello, world\n"

A sequence of characters in double quotes is called a character string or string constant.

char

A single byte, capable of holding one character in the local character set. 1. Unsigned: 255 2. Signed max: 127 3. Signed min: -128

Initialization of Character Arrays

A string may be used instead of the braces and commas notation. Ex: char pattern[] = "ould"; is the same as: char pattern[] = { 'o', 'u', 'l', 'd', '\0' }; - Remember to add the terminating '\0' to the size of the character array.

Side Effect

A variable is changed as a by-product of the evaluation of an expression.

Parameter

A variable named in the parenthesized list in a function definition. Ex: int power(int base, int n);

Pointer

A variable that contains the address of a variable. It is a group of cells that can hold an address. Ex: char *name int *name void *name

"I am a string"

An array of characters. In the internal representation, the array is terminated with the null character '\0' so that programs can find the end. - The length in storage is thus one more than the number of characters between the double quotes.

int

An integer, typically reflecting the natural size of integers on the host machine. 1. Unsigned: 4294967295 2. Signed max: 2147483647 3. Signed min: -2147483648

&&

And.

Declaration

Announces the properties of variables; it consists of a type name and a list of variables. Ex: int lower, upper, step;

argc

Argument Count. The number of command-line arguments the program was invoked with.

argv

Argument Vector. A pointer to an array of character strings that contain the arguments, one per string.

Cast

As if the expression were assigned to a variable of the specified type, which is then used in place of the whole construction. Construction: (type-name) expression Ex: sqrt( (double) n); - The cast produces the value of n in the proper type; n itself is not altered.

Assignment Operators

Assigns the value of its right operand to its left operand. Ex: += , -= , *= , /= , %=

a[i] can also be written as?

C converts it to *(a + i) immediately. 'a + i' is the address of the i-th element beyond a.

#define name replacement_text

Calls for a macro substitution of the simplest kind - subsequent occurrences of the token 'name' will be replaced by the 'replacement_text'. Ex: #define STEP 20

const

Can be applied to the declaration of any variable to specify that its value can not be changed. It can be used with array arguments to indicate that the function does not change the array. Ex: 1. const int variable; 2. int strlen(const char[ ]);

break Statement

Causes the innermost enclosing loop or switch to be exited immediately. It provides an early exit from a for, while, do loops & switch statements.

continue Statement

Causes the next iteration of the enclosing for, while, or do loop to begin. Applies only to loops, not switch statements.

//

Comment in C. Any characters after // are ignored by the compiler; they may be used freely to make a program easier to understand.

#if, #elif, #else, #endif

Conditional statements that are evaluated using preprocessing. Evaluates a constant integer expression. 1. If the expression is non-zero, subsequent lines until an #endif or #elif or #else are included. - defined('name') is a 1 if the 'name' is defined, otherwise it is a 0.

strcpy(s, t)

Copies the string t to the string s.

Block

Declarations and statements together grouped together using braces ({ and }). Used when expressions have more than one statement to execute. Ex: Functions, if, else, while, for

External Variables

Defined outside of any function, thus potentially available to many functions. They are permanent, so they retain values from one function invocation to the next.

*

Dereferencing operator. When applied to a pointer, it accesses the object the pointer points to.

double

Double-precision floating point. 1. Max: 1.79769e+308 2. Min: 2.22507e-308

&

Gives the address of an object. Only applied to objects, variables, and arrays in memory. Ex: p = &c; - Assigns the address of c to the variable p. p is said to "point to" c.

Arguments - Call by Value

In C, functions arguments are passed "by value". This means that the called function is given the values of its arguments in temporary variables rather than originals and it cannot directly alter a variable in the calling function, it can only alter its private, temporary copy.

;

In C, the semicolon is a statement terminator.

++

Increment by one.

Initialization of Arrays

Initialized by following its declaration with a list of initializers enclosed in braces and separated by commas. Ex: int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31} - When the size is omitted, the compiler will computer the length by counting the inializers.

==

Is equal to.

The Static Declaration

It is applied to an external variable or function to limit the scope of that object to the rest of the source file being compiled. The names will not conflict with the same names in other files of the same program. Ex: static char buf[BIFSIZE];

int *pa; pa = &a[0]; Then: *(pa + 1) equals?

It refers to the contents of a[1]. 1. pa + 1 is the address of a[i] 2. *(pa + i) is the contents of a[i]

Automatic Variables

Local variables in a function that come into existence only when the function is called, and disappears when the function is exited.

long

Long integer. 1. Unsigned: 18446744073709551615 2. Signed max: 9223372036854775807 3. Signed min: -9223372036854775808

char daytab[2][5] = {{0,1,2,3,4,5}, {6,7,8,9,10}};

Multi-dimensional Array. - If a two-dimensional array is to be passed to a function, the parameter declaration in the function must include the number of columns; the number of rows is irrelevant since what is passed is, as before, a pointer to an array of rows, where each row is an array of 13 ints. Ex: f(int daytab[2][5]);

\n

Newline character, which when printed advances the output to the left margin on the next line.

!=

Not equal to.

||

Or.

putchar(c)

Prints that contents of the integer variable c as a character, usually on the screen.

Function

Provides a convenient way to encapsulate some computation, which can then be used without worrying about its implementation.

getchar()

Reads the next input character from a text stream and returns that as its value. Ex: c = getchar()

Declaration of external variable

Refers to places where the property of the variable is stated but no storage is allocated. They do not create the variable or reserve storage for them. Ex: extern double val[];

Definition of an external variable

Refers to the place where the variable is created and assigned storage. Ex: double val[MAXVAL];

afree(n)

Releases the storage thus acquired so it can be re-used later. - The calls to afree must be made in the opposite order to the calls made on alloc. - The storage managed by alloc and afree is a stack, or last-in, first-out list.

alloc(n)

Returns a pointer 'p' to n-consecutive character positions, which can be used by the caller of the function for storing characters.

Return value of: char *month_name(int n);

Returns a pointer to a character string.

Assignment Statements

Set the variables to their initial values. Ex: lower = 0;

short

Short integer. 1. Unsigned: 65535 2. Signed max: 32767 3. Signed min: -32768

float

Single-precision floating point or numbers that have a fractional part. 1. Max: 3.40282e+38 2. Min: 1.17549e-38

#ifdef, #ifndef

Specialized forms that test whether a name is defined.

#include <stdio.h>

Standard Input/Output Library

do-while Loop

Tests the termination condition at the bottom after each pass through the loop body; the body is always executed at least once. 1. The statement is executed. 2. The expression is executed. If it is true, the statement is evaluated again and so on. 3. When the expression becomes false, the loop terminates.

int (*comp)(void *, void *)

The declaration states that comp is a pointer to a function that has two void * arguments and returns an int. - 'comp' is a pointer to the function - '*comp' is the function

n++ vs ++n

The expression ++n increments n before its value is used, while n++ increments n after its value has been used. Ex: int n =5; x = n++; sets x to 5 x = ++n; sets x to 6

return Statement

The mechanism for returning a value from the called function to its caller. The expression will be converted to the return type of the function if necessary.

else-if Statement

The most general way of writing a multi-way decision. 1. The expressions are evaluated in order. 2. If any expression is true, the block associated with it is executed and this terminates the whole chain.

Scope

The part of the program within which the variable can be used.

Advantage of Pointer Array over Multi-Dimensional Array

The rows of a pointer array may be of different lengths.

size_t

The unsigned integer type returned by the sizeof operator.

What is the value of an array type?

The value is the address of element zero of the array. Thus after assignment: pa = &a[0]; can also be written as: pa = a;

Argument

The value used in a call of the function. Ex: power(2, 1)

TorF: A pointer is constrained to point to a particular kind of object; every pointer points to a specific data type.

True but void *name is an exception. Ex: double *dp -Points to double data types

TorF: The purpose of supplying the size of an array in a declaration is to set aside storage.

True.

TorF: Since pointers are variables themselves, they can be stored in arrays just as other variables can.

True. - If the lines to be sorted are stored end-to-end in one long character array, then each line can be accessed by a pointer to its first character. The pointers themselves can be stored in an array.

TorF: In C, a function is not a variable but it is possible to define pointers to functions.

True. Functions can be assigned to pointers, placed in arrays, passed to functions, returned by functions, and so on. Picture: The qsort function expects an array of pointers, two integers, and a function with two pointer agruments.

TorF: Valid pointer operations are assignment of pointers of the same type, adding or subtracting a pointer and an integer, subtracting or comparing two pointers to members of the same array, and assigning or comparing to zero.

True. It is not legal to add two pointers, or to multiple or divide or shift or mask them, or to add float or double to them, or even, except for void *, to assign a pointer of one type to a pointer of another type without a cast.

TorF: 'char s[]' the same as 'char *s'?

True. The latter is preferred because it says more explicitly that the parameter is a pointer.

extern

Used if an external variable is to be referred to before it is defined, or if it is defined in a different source file from the one where it is being used.

if-else Statement

Used to express decisions. 1. The expression is evaluated; if it is true (non-zero), the block is executed. 2. If it is false, (zero) and there is an else part, that block is executed.

#include <filename>

Used to include the contents of a file during compilation. If the filename is quoted, searching for the file starts where the source code begins. if it is enclosed in < and >, searching follows an implementation-defined rule to find the file, a search is ussually made in a standard set of places, in the library directory of the compiler.

Recursion

When a function calls itself either directly or indirectly. The solution to a problem depends on solutions to smaller instances of the same problem (as opposed to iteration). - Each invocation of the function gets a fresh set of automatic variables. - Provides no saving in storage, nor is it faster. - But it is more compact, and often much easier to read and understand.

Signed variables

Will allow you to represent numbers both in the positive and negative ranges. Ex: A signed byte can represent -128 to 127.

Unsigned variables

Will only allow you to represent numbers in the positive. They can represent a larger magnitude number than the corresponding signed variable. Ex: An unsigned byte can represent values from 0 to 255

for (int a; condition, a ++) { statements} For Loop

Within the parentheses, there are three parts, separated by semicolons: 1. The first part, initialization is done once before the loop proper is entered. 2. The second part is the test or condition that controls the loop. If the condition is true, the body of the loop is executed. 3. Then the increment step is executed and the condition is re-evaluated. The loop terminates when the condition statement becomes false.

Arguments - Call by Reference

You can modify a variable in a function directly by passing in the address of the variable to be set. The called function must declare the parameter to be a pointer and access the variable indirectly through it.

char amessage[] = "now is the time"; vs. char *pmessage = "now is the time";

amessage is an array, just big enough to hold the sequence of characters and '\0' that initializes it. Individual characters within the array may be changed but amessage will always refer to the same storage. On the other hand, pmessage is a pointer, initialized to point to a string constant; the pointer may subsequently be modified to point elsewhere, but the result is undefined if you try to modify the string contents.

char **argv

argv: pointer to pointer to char

Conditional Expressions

expr1 ? expr2 : expr3; 1. The expression "expr1" is evaluated first. 2. If it is non-zero (true), then the expression "expr2" is evaluated and that is the value of the conditional expression. 3. Otherwise (false), "expr3" is evaluated, and that is the value. Ex: z = (a > b) ? a : b;