Main parts

1. A declaration tells the compiler the function name, return type and parameter types.
2. A definition contains the function body.
3. A call requests execution of the function with the required arguments.

Example explanation

The example defines add to receive two integers and return their sum. main calls add(4, 6). The function receives the values in a and b, calculates 10 and returns it. printf then displays the returned result. The function definition appears before main, so it also provides the required declaration before the call.

Advantages

1. Reusability: the same task can be called several times without copying its statements.
2. Readability: a meaningful name, such as calculate_total, explains the purpose of a block.
3. Testing: a small function is easier to check with selected inputs.
4. Maintenance: changing one function can update all places that call it.
5. Teamwork: different functions can be developed separately when their interfaces are agreed.

Important points

Keep each function focused on a clear task. Its parameter and return types form its interface: they describe how values enter and leave it. A function is not executed merely because it is defined; a call is needed. For the fixed integer addition shown here, time and extra working space are both O(1).

Flowchart

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int add(int a, int b)
{
    return a + b;
}
int main(void)
{
    printf("Sum = %d\n", add(4, 6));
    return 0;
}

Sum = 10

Related exam questions

Related questions in the function declarations category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• March/April 2023 · Q1(h) · 1 marks

  Define function signature.

  Paper P05 · page 1
• September 2023 · Q1(h) · 1 marks

  What is the signature of a function?

  Paper P06 · page 1

View this category in the exam question bank →

Declaration or prototype

int square(int number);

Meaning of the prototype

int before the name is the return type. square is the function name. int number specifies one integer parameter; the parameter name is optional in a prototype. The semicolon ends the declaration. A prototype does not contain the function body.

Definition

int square(int number)
{
    return number * number;
}

Function call

In square(5), the value 5 is supplied as an argument. Control enters the definition, number receives 5 and the expression number * number produces 25. return sends the value back to the caller. The example declares the function before main and defines it afterwards.

Important rules

1. Declare the function before its first call. Modern C does not provide an implicit function declaration.
2. Keep declarations and the definition compatible, including the return type and parameter types.
3. A prototype alone is not a definition; a used non-library function still needs a definition.
4. In C11, write f(void) to declare no parameters. A declaration f() does not specify the parameter types.

Why prototypes are useful

The compiler can detect many wrong argument counts and incompatible types when a prototype is visible. A prototype does not prove the function computes the right answer; the body must still be tested. The sample square value is deliberately small enough for int arithmetic.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int square(int number);
int main(void)
{
    printf("Square = %d\n", square(5));
    return 0;
}
int square(int number)
{
    return number * number;
}

Square = 25

Related exam questions

Related questions in the function declarations category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• March/April 2023 · Q1(h) · 1 marks

  Define function signature.

  Paper P05 · page 1
• September 2023 · Q1(h) · 1 marks

  What is the signature of a function?

  Paper P06 · page 1

View this category in the exam question bank →

No arguments and no return value

void greet(void)
{
    puts("Welcome");
}

Arguments and no return value

A function such as void show_square(int n) receives a number and displays its square. The caller supplies the input through an argument, but the function does not return a value. Displaying a result is an output action, not a returned value.

No arguments and a return value

A function such as int fixed_limit(void) can return a fixed limit without receiving arguments. It might instead obtain a value from another permitted source, but that is separate from the parameter list. The caller can store or use its returned value.

Arguments and a return value

A function such as int add(int a, int b) receives two numbers and returns their sum. This is useful when the caller should decide whether to print the result, store it or use it in another calculation.

Choosing a category

Choose the interface according to the task. Passing values as arguments makes a function easier to reuse than making every function read directly from the keyboard. Returning a calculated value often makes testing easier. A void function may still change an object through a pointer parameter or display output; void only says there is no returned value.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void greet(void) { puts("Welcome"); }
void show_square(int n) { printf("Square = %d\n", n * n); }
int fixed_limit(void) { return 10; }
int add(int a, int b) { return a + b; }
int main(void)
{
    greet();
    show_square(3);
    printf("Limit = %d\n", fixed_limit());
    printf("Sum = %d\n", add(4, 6));
    return 0;
}

Welcome
Square = 9
Limit = 10
Sum = 10

Related exam questions

Related questions in the function categories category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• March/April 2023 · Q8(a) · 5 marks

  Discuss types of functions based on parameters and return type.

  Paper P02 · page 2
• March/April 2023 · Q9(a) · 5 marks

  Explain differences between user-defined and library functions.

  Paper P02 · page 2

View this category in the exam question bank →

Actual arguments

An argument is an expression written in the call. In add(x, 5), the value of x and the value 5 are supplied. An argument can be a constant, variable or a more complex expression, provided its type and use are suitable for the function.

Formal parameters

Parameters are declared in the function definition. In int add(int a, int b), a and b are separate local parameter objects for each call. Their names need not be the same as the caller’s variable names. C passes values: changes to a or b alone do not change the caller’s ordinary integer variables.

Return communication

return expression; supplies one result value to the caller for a non-void function. The caller can assign that result to a variable, print it or use it in another expression. The return type describes the kind of result.

Example trace

If x contains 4, add(x, 5) supplies 4 and 5. The parameter objects receive those values. The function returns 9. If the caller writes result = add(x, 5);, result becomes 9 while x remains 4.

Important points

Use a visible prototype and compatible types. C does not generally specify the order in which different argument expressions are evaluated. Avoid calls that update the same variable in conflicting argument expressions. Prefer clear, independent arguments. Pointer-based output is introduced separately; the pointer value is still passed by value.

Related exam questions

Related questions in the function declarations category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• March/April 2023 · Q1(h) · 1 marks

  Define function signature.

  Paper P05 · page 1
• September 2023 · Q1(h) · 1 marks

  What is the signature of a function?

  Paper P06 · page 1

View this category in the exam question bank →

Syntax

return expression;  /* value-returning function */
return;             /* void function */

Return type

The type written before the function name specifies its result type. In double half(int n), the function returns a double. The expression n / 2.0 uses floating-point arithmetic, so half(7) returns 3.5. Returning a value can involve conversion to the declared return type.

Execution

When return is reached, later statements on that path in the same call do not execute. A function can contain several return statements for different conditions, but a particular call completes through only one return path. The caller resumes after the call with the returned result when there is one.

Important rules

1. Use return; in a void function, rather than returning an ordinary value.
2. Ensure every needed path of a value-returning function supplies a valid result. Falling off its end and then using the missing value has undefined behaviour, with the special main rule discussed separately.
3. In a hosted program, returning 0 from main reports successful completion. Reaching the closing brace of main also returns 0.
4. Do not return a pointer to an ordinary automatic local object: that object no longer exists after the call ends.

Example purpose

The sample separates calculation from display. half performs the calculation; main decides the output format. This allows the result to be used in a later calculation without changing half.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
double half(int n)
{
    return n / 2.0;
}
int main(void)
{
    printf("Half = %.1f\n", half(7));
    return 0;
}

Half = 3.5

Related exam questions

Related questions in the function declarations category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• March/April 2023 · Q1(h) · 1 marks

  Define function signature.

  Paper P05 · page 1
• September 2023 · Q1(h) · 1 marks

  What is the signature of a function?

  Paper P06 · page 1

View this category in the exam question bank →

Working

1. The caller evaluates the argument expression.
2. The resulting value is used for the parameter according to the declared type.
3. The function works with its parameter object. Assigning a new value to that parameter does not assign to the caller’s variable.

Example trace

main starts with number = 10 and calls change(number). The parameter n receives 10. Inside change, n = 25 changes only n, so the first line prints 25. After the function returns, number in main still contains 10. This shows the difference between a copied value and the original object.

Advantages

A function can use and update a working parameter without unintentionally replacing the caller’s ordinary value. This helps keep calculations separate. For example, a digit-processing function can repeatedly divide its local copy while the original input remains available to main.

Pointer clarification

Passing an address does not change C into pass by reference. The address is a pointer value, and that value is copied into a pointer parameter. The function can use the copied pointer to access the same caller-owned object. Changing the pointer parameter itself is different from changing the object to which it points.

Complexity

The fixed-size integer example uses constant work and a fixed number of objects, so time and extra space are O(1). The copying cost of an argument depends on its type; do not assume every possible argument is a single small integer.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void change(int n)
{
    n = 25;
    printf("Inside = %d\n", n);
}
int main(void)
{
    int number = 10;
    change(number);
    printf("Outside = %d\n", number);
    return 0;
}

Inside = 25
Outside = 10

Related exam questions

Related questions in the function arguments category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• March/April 2023 · Q1(g) · 2 marks

  Define formal arguments.

  Paper P02 · page 1
• March/April 2023 · Q8(b) · 5 marks

  Write a C program using functions to swap two numbers using global variables and the call-by-reference concept.

  Paper P02 · page 2

View this category in the exam question bank →

Required notation

1. int *p declares a parameter that can hold the address of an int.
2. &x obtains the address of x.
3. *p accesses the int identified by p. An assignment such as *p = 20 changes that object.

Swap algorithm

1. Save the value of *a in a temporary integer.
2. Copy *b into *a.
3. Copy the temporary value into *b.

Example trace

main starts with x = 4 and y = 9. swap(&x, &y) passes their addresses. The parameter a identifies x and b identifies y. temporary receives 4, *a becomes 9 and *b becomes 4. After the call, the original objects in main contain the swapped values.

Important distinction

This is often called call by address in introductory courses. C itself still passes arguments by value: the pointer values are copied. Assigning a different address to the local parameter a would not change a caller pointer variable. Assigning to *a changes the object reached through the copied pointer.

Validity and complexity

Both pointers must identify suitable live, writable int objects before they are dereferenced. The example always passes addresses of local variables that remain alive during the call. There are three fixed assignments and one temporary integer, so the swap takes O(1) time and O(1) auxiliary space. Full pointer details belong to Unit V.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void swap(int *a, int *b)
{
    int temporary = *a;
    *a = *b;
    *b = temporary;
}
int main(void)
{
    int x = 4, y = 9;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

x = 9, y = 4

Related exam questions

Related questions in the function arguments category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• March/April 2023 · Q1(g) · 2 marks

  Define formal arguments.

  Paper P02 · page 1
• March/April 2023 · Q8(b) · 5 marks

  Write a C program using functions to swap two numbers using global variables and the call-by-reference concept.

  Paper P02 · page 2

View this category in the exam question bank →

Block scope

A local variable declared in a block can normally be used from its declaration to the end of that block. Nested blocks can use a visible outer name unless an inner declaration hides it. Function parameters in a definition are available within that function body.

File scope

An object declared outside every function has file scope. Its name is visible from its declaration to the end of the translation unit, subject to hiding. A translation unit is roughly a source file after preprocessing, including text brought in from headers. Linkage determines whether declarations can refer to the same entity across translation units.

Example trace

The file-scope value is 10. Inside main, a local value is declared as 20, hiding that file-scope name. A nested block declares another value as 30, which hides the outer local name inside that block. The lines therefore print 20, 30 and 20. The object with value 20 was not changed by declaring the inner object.

Other scopes and good practice

C also has function scope for labels and function-prototype scope for parameter names in prototypes. Use descriptive names and avoid unnecessary hiding, because similar names can confuse readers. A local static object has block scope but lasts throughout execution; this is why scope and lifetime must be studied separately.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int value = 10;
int main(void)
{
    int value = 20;
    printf("Outer = %d\n", value);
    {
        int value = 30;
        printf("Inner = %d\n", value);
    }
    printf("Outer again = %d\n", value);
    return 0;
}

Outer = 20
Inner = 30
Outer again = 20

Related exam questions

Related questions in the storage classes category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q1(b) · 8 marks

  If a variable has auto storage class by default, why was the auto keyword introduced in C? Explain.

  Paper P01 · page 1
• July 2021 · Q2(c) · 5 marks

  List and explain storage classes in C.

  Paper P04 · page 1

View this category in the exam question bank →

Scope: where a name is visible

A name declared inside a block generally has block scope. Outside that scope, the same spelling cannot be used to reach that declaration. Scope is a source-code rule about names, rather than a count of seconds or function calls.

Lifetime: when an object exists

An ordinary automatic local object is associated with a particular execution of its block. A static-duration object exists throughout program execution. A function call can end the lifetime of an ordinary automatic local object while a local static object continues to exist. Allocated objects have a different lifetime managed through memory allocation, covered in Unit V.

Linkage: whether declarations identify the same entity

External linkage can connect declarations across translation units. Internal linkage connects declarations within one translation unit. A typical local variable has no linkage. Linkage is not the same as visibility: a file-scope static object has internal linkage, while a block-local static object has no linkage.

Example

In void count(void) { static int total = 0; ++total; }, the name total has block scope. Its object has static storage duration, so the value can remain after count returns. A later call uses the same object. Scope is local, but the lifetime is not limited to one call.

Why the distinction matters

Do not return a pointer to an ordinary local object that stops existing when the call ends. Do not assume that a local name always describes temporary storage. State scope, storage duration and linkage separately when comparing storage classes.

Related exam questions

Related questions in the storage classes category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q1(b) · 8 marks

  If a variable has auto storage class by default, why was the auto keyword introduced in C? Explain.

  Paper P01 · page 1
• July 2021 · Q2(c) · 5 marks

  List and explain storage classes in C.

  Paper P04 · page 1

View this category in the exam question bank →

Declaration

auto int count = 0;
int other_count = 0; /* also automatic here */

Main properties

1. Scope is normally the enclosing block, from the declaration onwards.
2. The local object has no linkage.
3. A new block execution has its own automatic object.
4. An initialiser is applied when the declaration is reached. Without a suitable initialisation, an ordinary automatic object does not have a useful guaranteed starting value.

Example trace

Each call to show creates its automatic count and initialises it to zero. The increment makes it 1, so three separate calls print 1, 1 and 1. The value is not saved for the next call. A local static counter behaves differently because it refers to one lasting object.

Uses

Automatic variables are suitable for temporary calculations, counters and intermediate results that belong to one call. Recursive calls can each have their own automatic parameter and local values. This helps one call avoid overwriting another call’s ordinary locals.

Important points

Initialise before reading. Avoid returning the address of an ordinary automatic local object because its lifetime ends when its block execution ends. auto does not mean that the compiler should infer the type in the C11 examples used here; the keyword must be understood in the selected language version.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void show(void)
{
    auto int count = 0;
    ++count;
    printf("%d\n", count);
}
int main(void)
{
    show(); show(); show();
    return 0;
}

1
1
1

Related exam questions

Related questions in the storage classes category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q1(b) · 8 marks

  If a variable has auto storage class by default, why was the auto keyword introduced in C? Explain.

  Paper P01 · page 1
• July 2021 · Q2(c) · 5 marks

  List and explain storage classes in C.

  Paper P04 · page 1

View this category in the exam question bank →

Declaration

register int i;

Main properties

1. A register object at block scope has automatic storage duration.
2. Its name has block scope and no linkage.
3. It needs a valid value before it is read, just like an ordinary automatic local object.
4. C11 does not permit taking its address with &.

Example explanation

The sample uses i as a small loop counter. It starts at 1, and each iteration adds i to sum. After i = 3 is processed, sum is 6. The loop would calculate the same result if register were omitted. A modern optimiser can choose efficient storage for ordinary variables too.

Restrictions and limitations

Do not write &i for a C11 register object. Consequently, a register int cannot directly be supplied to scanf as &i. The keyword is not a request for persistent storage and does not preserve a value across calls. It is also not a way to make shared updates safe between threads.

Complexity

The example performs one addition for each value from 1 through n in its general form, so the loop takes O(n) time and O(1) auxiliary space. Adding register does not change that growth rate. Optimisation of a particular build and algorithm complexity are separate matters.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int main(void)
{
    int sum = 0;
    for (register int i = 1; i <= 3; ++i) { sum += i; }
    printf("Sum = %d\n", sum);
    return 0;
}

Sum = 6

Related exam questions

Related questions in the storage classes category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q1(b) · 8 marks

  If a variable has auto storage class by default, why was the auto keyword introduced in C? Explain.

  Paper P01 · page 1
• July 2021 · Q2(c) · 5 marks

  List and explain storage classes in C.

  Paper P04 · page 1

View this category in the exam question bank →

Local static object

In static int count = 0; inside a function, count has block scope and static storage duration. It is not recreated on every call. In these C examples its initial value is established before program startup, and later calls use the same object. If no initialiser is supplied, an arithmetic static-duration object is initialised to zero.

Example trace

The first call to visit increments count from 0 to 1. The second increments the same object to 2, and the third to 3. The output is therefore 1, 2 and 3. Contrast this with an automatic count initialised to zero on every call, which would print 1 each time.

File-scope static

At file scope, static int total; defines a static-duration object with internal linkage. Other translation units cannot connect an external declaration to that entity. A static function at file scope also has internal linkage. This helps keep implementation details within one translation unit.

Uses and limitations

1. Local static objects can store a call count or a small amount of lasting state.
2. File-scope static helps avoid exporting names that other source files do not need.
3. Persistent shared state can make testing and repeated calls depend on earlier calls.
4. static does not automatically make an update thread-safe.

Important distinction

A local static object has no linkage; a file-scope static object has internal linkage. Both have static storage duration, but their scopes are different.

Flowchart

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void visit(void)
{
    static int count = 0;
    ++count;
    printf("%d\n", count);
}
int main(void)
{
    visit(); visit(); visit();
    return 0;
}

1
2
3

Related exam questions

Related questions in the storage classes category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q1(b) · 8 marks

  If a variable has auto storage class by default, why was the auto keyword introduced in C? Explain.

  Paper P01 · page 1
• July 2021 · Q2(c) · 5 marks

  List and explain storage classes in C.

  Paper P04 · page 1

View this category in the exam question bank →

Declaration and definition

extern int total; /* declaration */
int total = 10;   /* definition at file scope */

Working

The declaration tells the compiler the name and type. The definition supplies the object. When compatible declarations have external linkage, they can refer to the same object across translation units. A header can contain an extern declaration while one source file contains the definition.

Example explanation

In the complete single-file example, total is declared before main and defined after main. The earlier declaration makes the name available when main is compiled. The definition gives total the initial value 10, which main prints. The order is chosen to show the difference clearly.

Important rules

1. Keep the declared type compatible with the definition.
2. Provide one required external definition rather than putting an ordinary initialised definition in every included header.
3. Do not assume extern makes a previously hidden name visible automatically: a declaration must appear in an appropriate scope.
4. An extern declaration with an initialiser at file scope is a definition, so the initialiser changes the situation.

Linkage and storage duration

An object declared with external linkage has static storage duration. However, extern is not simply another word for global: a block-scope extern declaration can refer to an object defined outside that block. Linkage also depends on prior visible declarations, so avoid the oversimplification that extern always overrides an earlier static declaration.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
extern int total;
int main(void)
{
    printf("Total = %d\n", total);
    return 0;
}
int total = 10;

Total = 10

Related exam questions

Related questions in the storage classes category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q1(b) · 8 marks

  If a variable has auto storage class by default, why was the auto keyword introduced in C? Explain.

  Paper P01 · page 1
• July 2021 · Q2(c) · 5 marks

  List and explain storage classes in C.

  Paper P04 · page 1

View this category in the exam question bank →

Auto

A block-local auto object has automatic storage duration and no linkage. It is normally created for an execution of its block. Without a valid initialisation, an ordinary automatic scalar does not have a useful guaranteed starting value.

Register

A block-local register object is also automatic and has no linkage. It suggests frequent access, but the compiler does not have to place it in a hardware register. In C11, its address cannot be taken with &.

Static

A local static object has block scope, no linkage and a lifetime covering program execution. It retains its value across calls. A file-scope static object instead has file scope and internal linkage. Arithmetic objects with static storage duration are initialised to zero if no explicit initialiser is given.

Extern

A common extern declaration refers to an object defined elsewhere. That object can be shared across source files through compatible external-linkage declarations. A declaration without an initialiser does not ordinarily create a separate new object.

Example and important distinction

Use an automatic temporary for a calculation needed only during one call. Use a local static counter when lasting state is intentional. Use an extern declaration when referring to a shared definition. Do not choose a class solely by a simplified memory-location table: C does not require automatic objects to occupy a particular physical stack or register. State scope, duration and linkage separately.

Comparison table

Related exam questions

Related questions in the storage classes category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q1(b) · 8 marks

  If a variable has auto storage class by default, why was the auto keyword introduced in C? Explain.

  Paper P01 · page 1
• July 2021 · Q2(c) · 5 marks

  List and explain storage classes in C.

  Paper P04 · page 1

View this category in the exam question bank →

Const

const int limit = 10; declares an object that cannot be assigned a new value through limit. A pointer to const can be used to allow reading without allowing modification through that pointer. const does not automatically make a C object an integer constant expression. Casting away const does not make an originally const-defined object safely writable.

Volatile

volatile tells the implementation that accesses to an object have significance beyond ordinary calculations. It is used in implementation-specific hardware interfaces and suitable signal-handling situations. It does not guarantee atomic updates, mutual exclusion or thread synchronisation. A variable changing between threads needs the appropriate atomic or locking rules.

Restrict

restrict is mainly used with pointer types. It expresses an access promise about the objects reached through pointers during the relevant execution. This can help optimisation when the promise is valid. It does not check the promise at runtime; violating the required access rules can cause undefined behaviour. Full pointer examples are deferred to Unit V.

Simple example

The program declares a const rate and uses it to compute an amount. The rate can be read, but an assignment such as rate = 0.10 is not allowed through that name. The program does not contain that invalid assignment.

Important distinction

Qualifiers are not storage classes. A const object can still be an automatic local or have static storage duration, depending on its declaration. Qualifying a type does not by itself select a hardware memory location.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int main(void)
{
    const double rate = 0.05;
    double amount = 200.0 * rate;
    printf("Amount = %.2f\n", amount);
    return 0;
}

Amount = 10.00

Main directives

1. #include makes header contents available for preprocessing.
2. #define creates an object-like or function-like macro.
3. #undef removes a macro definition.
4. #if, #ifdef, #ifndef, #elif, #else and #endif control which source text is included.
5. #error requests a diagnostic when a required configuration is missing or invalid.

Header inclusion

Use #include <stdio.h> for the standard input/output declarations. Quoted inclusion, such as #include "settings.h", is commonly used for project headers. The implementation defines the precise search rules. Including a header is not the same as copying the compiled implementation of every library function into the program.

Example explanation

The sample defines LIMIT as 3. During preprocessing, uses of the macro name are replaced by its replacement tokens. The resulting loop prints 1, 2 and 3. The macro is not an ordinary int variable and does not have a separate object storing 3.

Why it is useful

Headers support shared declarations. Macros can name configuration values, and conditional compilation can choose platform or debug code. These operations affect the translated source; an ordinary runtime if instead makes a decision while the program is running.

Important points

Do not put a semicolon after a simple numeric macro unless a semicolon is intentionally part of the replacement. Macros are not checked like typed function parameters. Inspect expanded expressions carefully, especially when arithmetic operators or repeated arguments are involved.

Flowchart

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#define LIMIT 3
int main(void)
{
    for (int i = 1; i <= LIMIT; ++i) { printf("%d\n", i); }
    return 0;
}

1
2
3

Related exam questions

Related questions in the preprocessor category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q3(b) · 8 marks

  What is the use of preprocessor directives? Explain.

  Paper P01 · page 1
• March/April 2023 · Q1(e) · 2 marks

  Differentiate #undef and #ifndef.

  Paper P02 · page 1

View this category in the exam question bank →

Object-like macro

#define LIMIT 100

Function-like macro

#define SQUARE(x) ((x) * (x))

Expansion example

SQUARE(2 + 3) expands to ((2 + 3) * (2 + 3)), giving 25. Without the parameter parentheses, an expansion such as 2 + 3 * 2 + 3 would give 11. The outer parentheses also protect the full result when it is placed inside another expression.

Repeated evaluation

The parameter x occurs twice in SQUARE. Therefore its argument expression also appears twice after replacement. Do not write SQUARE(i++): the resulting expression modifies i without the ordering required by C and has undefined behaviour. Parentheses do not solve that problem. A typed function such as int square(int x) evaluates an argument once before using its parameter.

Comparison with functions

A function has a declared interface, parameter objects and a return type. A macro is token replacement and does not provide the same parameter type checking. A compiler may inline a real function, so do not assume a macro must be faster. Prefer a function for ordinary calculations unless a macro is specifically useful.

Other points

There must be no space between a function-like macro name and the opening parenthesis in its definition. #undef SQUARE removes the definition for later source. Avoid an accidental trailing semicolon in a simple expression macro.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#define SQUARE(x) ((x) * (x))
int main(void)
{
    printf("Square = %d\n", SQUARE(2 + 3));
    return 0;
}

Square = 25

Related exam questions

Related questions in the preprocessor category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q3(b) · 8 marks

  What is the use of preprocessor directives? Explain.

  Paper P01 · page 1
• March/April 2023 · Q1(e) · 2 marks

  Differentiate #undef and #ifndef.

  Paper P02 · page 1

View this category in the exam question bank →

Common directives

1. #if tests a permitted preprocessing constant expression.
2. #ifdef NAME checks whether NAME is defined.
3. #ifndef NAME checks whether NAME is not defined.
4. #elif and #else select alternative groups.
5. #endif ends the conditional group.

Example explanation

The sample sets DEBUG to 1. #if DEBUG includes the debug message in the translated source, followed by the Ready message. If DEBUG were defined as 0, that debug line would be excluded. In contrast, #ifdef DEBUG would still succeed because the macro would remain defined.

Header guard

#ifndef CODEBHAVYA_SETTINGS_H
#define CODEBHAVYA_SETTINGS_H
/* declarations */
#endif

Why a guard is needed

The first inclusion defines the guard macro and includes the guarded contents. If the same header is included again in that translation unit, the macro already exists, so the contents are skipped. This prevents many repeated declarations or definitions from being processed incorrectly. It does not make an ordinary shared object definition safe to place in every source file; use suitable extern declarations.

Uses and precautions

Conditional compilation can select debug messages, optional features or platform-specific code. Use meaningful project-prefixed macro names and correctly pair each group with #endif. Do not use a runtime variable as though its value were available during preprocessing. A C const int object is not automatically a preprocessing macro or a permitted #if value.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#define DEBUG 1
int main(void)
{
#if DEBUG
    puts("Debug enabled");
#endif
    puts("Ready");
    return 0;
}

Debug enabled
Ready

Related exam questions

Related questions in the preprocessor category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q3(b) · 8 marks

  What is the use of preprocessor directives? Explain.

  Paper P01 · page 1
• March/April 2023 · Q1(e) · 2 marks

  Differentiate #undef and #ifndef.

  Paper P02 · page 1

View this category in the exam question bank →

Base case

The base case is a condition whose answer is known without another recursive call. In a countdown, n <= 0 can be the stopping case. In factorial, n <= 1 returns 1 for the supported non-negative inputs.

Recursive case

The recursive case calls the function with a smaller or otherwise simpler input. countdown(n - 1) moves a positive integer closer to zero. Merely writing a self-call is not enough: it must move towards termination for every supported input.

Example trace

countdown(3) prints 3 and calls countdown(2). That call prints 2 and calls countdown(1). The next call prints 1 and calls countdown(0). At zero the function returns immediately. The earlier calls then finish in reverse order. Each call has its own parameter object.

Advantages and limitations

1. It can express naturally recursive problems clearly, such as tree traversal and divide-and-conquer algorithms.
2. The base case and smaller subproblem can make the reasoning easy to state.
3. Active calls require execution resources; very deep recursion can exhaust the available call capacity.
4. Repeatedly solving the same subproblem can make a naive recursive algorithm slow.

Complexity

For a countdown from n, there are n printing calls and one base-case call. Time is O(n). With the usual model of one active call record per unfinished call, auxiliary space is O(n). C does not guarantee tail-call optimisation, so do not assume it removes the call depth.

Flowchart

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void countdown(int n)
{
    if (n <= 0) { return; }
    printf("%d\n", n);
    countdown(n - 1);
}
int main(void)
{
    countdown(3);
    return 0;
}

3
2
1

Related exam questions

Related questions in the recursion category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q8(a) · 7 marks

  Explain recursion with an example program.

  Paper P01 · page 1
• March/April 2023 · Q9(b) · 5 marks

  What is recursion? State its advantages and disadvantages.

  Paper P02 · page 2

View this category in the exam question bank →

Algorithm

1. Read n and accept values from 0 through 20.
2. If n <= 1, return 1.
3. Otherwise, return n multiplied by factorial(n - 1).
4. Display the returned result.

Call and return trace

For n = 4, the calls ask for factorial(4), factorial(3), factorial(2) and factorial(1). The final call returns 1. The pending multiplications then produce 2 × 1 = 2, 3 × 2 = 6 and 4 × 6 = 24. The original call returns 24 to main.

Why it stops

Every recursive call decreases a supported positive n by one. It eventually reaches 1, which is a base case. Input zero is also handled by the base case. main rejects negative input before converting it to unsigned, preventing an unintended very large unsigned value.

Input and type limits

The result uses unsigned long long and the matching output format %llu. The supported limit 20 ensures that 20! fits the minimum range guaranteed for that type. A wider integer still has a finite range, so recursion cannot calculate arbitrary factorials accurately with this fixed type.

Time complexity

There is one smaller recursive call per level, with constant work apart from the call. The number of levels grows in proportion to n, giving O(n) time in the fixed-width model.

Space complexity

Pending calls wait for smaller results before multiplying. There are O(n) active calls in the usual call-record model, so auxiliary space is O(n). An iterative factorial can perform the same number of multiplications with O(1) auxiliary space.

Flowchart

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
unsigned long long factorial(unsigned int n)
{
    if (n <= 1U) { return 1ULL; }
    return n * factorial(n - 1U);
}
int main(void)
{
    int n;
    if (scanf("%d", &n) != 1 || n < 0 || n > 20) {
        puts("Unsupported input"); return 1;
    }
    printf("Factorial = %llu\n", factorial((unsigned int)n));
    return 0;
}

4

Factorial = 24

Related exam questions

Related questions in the recursion category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q8(a) · 7 marks

  Explain recursion with an example program.

  Paper P01 · page 1
• March/April 2023 · Q9(b) · 5 marks

  What is recursion? State its advantages and disadvantages.

  Paper P02 · page 2

View this category in the exam question bank →

Recursive rule

gcd(a, b) = a                 when b == 0
gcd(a, b) = gcd(b, a % b)     otherwise

Algorithm

1. Read two non-negative integers within the supported range. Reject the pair 0, 0.
2. If b is zero, return a.
3. Otherwise, call gcd with b and a % b.
4. Return the smaller call’s result and display it.

Worked trace

For 48 and 18, the first remainder is 12, so the next pair is (18, 12). The next remainder is 6, giving (12, 6). The next remainder is zero, giving (6, 0). The base case returns 6. Earlier calls return the same value, so the greatest common divisor is 6.

Why the rule works

Replacing a by a - q × b does not change the common divisors of a and b. The remainder a % b is exactly that difference for the integer quotient q. Thus the common divisors remain the same while the values become smaller. For positive b, the non-negative remainder is less than b, ensuring progress.

Boundary cases

gcd(a, 0) returns a for positive a; gcd(0, b) returns b for positive b. This program rejects (0, 0) rather than assigning it an elementary greatest-positive-divisor result.

Complexity

For positive inputs, Euclid’s algorithm uses O(log min(a, b)) remainder steps; more precisely the boundary cases can be expressed using 1 + min(a, b). Each one or two steps substantially reduces the smaller positive value. Recursive auxiliary space follows the number of active calls. Zero-input cases finish in constant work. This analysis treats fixed-width arithmetic operations as constant time.

C program and output

/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
unsigned int gcd(unsigned int a, unsigned int b)
{
    if (b == 0U) { return a; }
    return gcd(b, a % b);
}
int main(void)
{
    int a, b;
    if (scanf("%d%d", &a, &b) != 2 || a < 0 || b < 0 ||
        a > 10000 || b > 10000 || (a == 0 && b == 0)) {
        puts("Unsupported input"); return 1;
    }
    printf("GCD = %u\n", gcd((unsigned int)a, (unsigned int)b));
    return 0;
}

48 18

GCD = 6

Related exam questions

Related questions in the recursion category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q8(a) · 7 marks

  Explain recursion with an example program.

  Paper P01 · page 1
• March/April 2023 · Q9(b) · 5 marks

  What is recursion? State its advantages and disadvantages.

  Paper P02 · page 2

View this category in the exam question bank →

Recursion

Recursive factorial returns 1 at its base case and otherwise returns n × factorial(n - 1). Each active call waits for the smaller result. The definition closely follows the mathematical relationship. With n levels it takes O(n) time and O(n) auxiliary space in the usual call-record model.

Iteration

Iterative factorial starts result at 1 and multiplies it by each value from 2 through n. There is no chain of pending recursive calls. It also takes O(n) time, because the number of multiplications grows linearly. Only a counter and result are needed, giving O(1) auxiliary space.

Comparison

1. Stopping: recursion uses a base case; iteration uses a loop condition or an explicit exit.
2. Stored state: recursion can keep separate state in active calls; iteration uses explicit variables.
3. Readability: recursive problems such as tree traversal may be easier to describe recursively.
4. Limits: deep recursion can exhaust call resources; a loop can still be wrong or non-terminating if its progress rule is faulty.

Which should be chosen?

For a simple factorial, iteration usually avoids unnecessary call depth. For naturally recursive structures, recursion can be clearer. Neither form is always faster or always better. Count the actual work and stored state. C does not guarantee tail-call optimisation, so it cannot be assumed to reduce every recursive function to constant extra space.

Correctness

Both forms must handle 0! = 1, reject unsupported negative input and avoid overflowing the result type. Changing recursion to a loop does not remove arithmetic limits.

Comparison table

Related exam questions

Related questions in the recursion category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.

• September/October 2021 · Q8(a) · 7 marks

  Explain recursion with an example program.

  Paper P01 · page 1
• March/April 2023 · Q9(b) · 5 marks

  What is recursion? State its advantages and disadvantages.

  Paper P02 · page 2

View this category in the exam question bank →