In the early days of learning C, most programs feel like long stories without chapters. Everything lives inside main(), tangled and noisy. But real problem solving in programming begins when you learn to divide, delegate, and design cleanly.
That’s where top-down design, functions, and pointers step into the spotlight.
This chapter is about teaching your programs to think in well-cut pieces rather than giant monologues.
1. Top-Down Design: Breaking Big Problems into Friendly Pieces
Top-down design is exactly what it sounds like:
Start with the big idea. Then break it into smaller ideas. Then break those into even smaller ideas.
It’s how architects design cities and how developers design real software.
A Visual Snapshot
In C, these “subtasks” become functions — reusable little workers that help your program stay readable and flexible.
2. Using Existing Knowledge: Library Functions
Before writing your own functions, C hands you a toolbox filled with ready-made functionality.
Some classics:
-
printf()for formatted output -
scanf()for input -
sqrt()for square roots -
strlen(),strcpy()for strings
Using library functions is like relying on public utilities instead of building your own water pump.
3. Structure Charts: A Visual Map of Your Program
Structure charts turn ideas into a blueprint.
Example: Program to compute the average of numbers.
+-------------------+
| main() |
+-------------------+
/ \
/ \
+----------------+ +----------------+
| readNumbers() | | computeAvg() |
+----------------+ +----------------+
Each box is a function.
Arrows show who calls whom.
It’s programming with a bird’s-eye view.
4. Functions Without Arguments
Not every function needs input.
Some simply perform a task.
Example:
void greet() {
printf("Welcome to the Program!\n");
}
int main() {
greet();
return 0;
}
This is top-down design in action:
main() delegates → greet() executes the detail.
5. Functions with Input Arguments
Functions often require data to work with.
int square(int x) {
return x * x;
}
Arguments behave like “packages” delivered into the function.
6. Pointers: The New Dimension of C
Pointers are variables that store memory addresses.
Think of them as little paper slips with directions to where a value lives.
+-----------+ +---------+
| pointer p | ----> | value |
| stores &x | | x |
+-----------+ +---------+
* operator lets you reach through the pointer and access the target value.Pointers feel abstract at first, but soon they become the backbone of dynamic memory, arrays, strings, and modular programming.
7. Functions with Output Parameters
Sometimes you want a function to return more than one value.
In C, pointers make this possible.
Example: returning both sum and product.
Call:
Diagram:
Pointers help your function send results back to the caller.
8. Multiple Calls with Input/Output Parameters
You can reuse output parameters across multiple function calls.
Example: updating a running total:
void addToTotal(int value, int *total) {
*total += value;
}
int total = 0;
addToTotal(5, &total); // total = 5
addToTotal(3, &total); // total = 8
This pattern appears everywhere — from calculator apps to statistical algorithms.
9. Scope of Names: Where Variables Live
Scope decides who can see a variable.
Local Scope
Variables declared in functions exist only inside them.
Global Scope
Variables declared outside all functions can be accessed anywhere.
int g = 10; // global
void f() {
int x = 5; // local
}
A program with poor scope control becomes noisy and confusing.
Modular design prefers locals whenever possible.
10. Formal Output Parameters as Actual Arguments
“Formal parameter” = variable inside the function
“Actual parameter” = value/variable you pass from the outside
With pointers, the actual argument must be an address.
Example:
int n;
readValue(&n); // &n is the actual argument
Inside the function:
This technique lets functions modify variables that live in the caller.
Why This Unit Matters
Top-down design teaches clarity.
Functions teach reusability.
Pointers teach power.
Together, they shape you into a programmer who thinks in modules, not tangled lines. These concepts form the backbone of problem solving in C, from small student programs to large systems in the real world.
MCQs on UNIT–II: Functions, Top-Down Design & Pointers
1. Top-Down Design focuses on:
A. Writing code first and designing later
B. Starting with details and working upward
C. Breaking a problem into smaller subproblems
D. Ignoring program structure
Answer: C
2. A structure chart represents:
A. Logical flow of loops
B. Function calling hierarchy
C. Memory allocation
D. Only pointers
Answer: B
3. A function without arguments:
A. Cannot return a value
B. Is illegal in C
C. Can still perform tasks
D. Must return a pointer
Answer: C
4. Library functions are stored in:
A. stdlib.h
B. Program memory only
C. Header files
D. Operating system kernel
Answer: C
5. Which operator retrieves the value stored in the address pointed to by a pointer?
A. &
B. *
C. ->
D. %
Answer: B
6. Which operator gives the address of a variable?
A. *
B. ->
C. &
D. #
Answer: C
7. A function with input arguments:
A. Cannot modify values
B. Receives data from the calling function
C. Must return a pointer
D. Is always inline
Answer: B
8. In C, a function can return:
A. Only one value
B. Only character values
C. Multiple values
D. Unlimited values
Answer: A
(Multiple returned indirectly through pointers)
9. A function using output parameters must use:
A. Arrays
B. Pointers
C. Recursion only
D. Global variables
Answer: B
10. The scope of a local variable is limited to:
A. Entire program
B. Multiple files
C. The function/block in which it is declared
D. The main function only
Answer: C
11. Which of the following is valid pointer declaration?
A. int p;
B. pointer p;
C. int *p;
D. int &p;
Answer: C
12. Dereferencing a pointer means:
A. Accessing the value pointed to
B. Changing the pointer type
C. Linking two functions
D. Accessing global variables
Answer: A
13. Which of the following can pass multiple values back to the caller?
A. Inline functions
B. Functions with return only
C. Functions with pointer output parameters
D. Conditional operators
Answer: C
14. The actual parameter is the:
A. Variable inside the function
B. Value passed by the caller
C. Value returned by the function
D. Pointer type declaration
Answer: B
15. Formal parameters are:
A. Values passed from main()
B. Arguments declared in the function definition
C. Pointers only
D. Always integers
Answer: B
16. Which of the following BEST supports modular programming?
A. Large single function
B. Global variables
C. Functions with well-defined tasks
D. Recursion everywhere
Answer: C
17. Multiple calls to a function with input/output parameters:
A. Is not allowed
B. Requires static variables
C. Updates caller variables via pointers
D. Runs only once
Answer: C
18. Which is true about top-down design?
A. Encourages code repetition
B. Hard to maintain
C. Reduces complexity
D. Ignores main logic
Answer: C
19. A pointer that stores no valid address is called:
A. Dangling pointer
B. Null pointer
C. Memory leak
D. Wild pointer
Answer: B
20. The * operator is also called:
A. Indirection operator
B. Reference operator
C. Scope operator
D. Structure operator
Answer: A
21. Formal output parameters must be:
A. Arrays
B. Found in header files
C. Pointer variables
D. Float type only
Answer: C
22. Which is NOT an advantage of functions?
A. Reusability
B. Reduced code size
C. Faster execution always
D. Easier debugging
Answer: C
(Functions may not always be faster)
23. The address operator cannot be applied to:
A. int variables
B. float variables
C. arrays
D. constants and expressions
Answer: D
24. In C, pointers enable:
A. Dynamic memory access
B. Returning multiple values
C. Efficient array handling
D. All of the above
Answer: D
25. Which of the following can modify a variable inside main()?
A. Passing by value
B. Passing by pointer
C. Passing constant arguments
D. Returning a value without storing
Answer: B
26. Which is the correct syntax for a function with no arguments?
A. void func();
B. func void();
C. void func(noargs);
D. none
Answer: A
27. A structure chart does NOT show:
A. Function hierarchy
B. Data flow
C. Code statements
D. Module relationships
Answer: C
28. What is the output of dereferencing a pointer to an integer?
A. Memory address
B. Integer value stored
C. Type of pointer
D. Compilation error
Answer: B
29. A modular program’s main() should ideally contain:
A. All computations
B. Only function calls
C. All variable declarations
D. Infinite loops
Answer: B
30. If a function should modify two variables from main(), it should:
A. Return a struct
B. Use two pointer parameters
C. Use global variables only
D. Use inline assembly
Answer: B
Comments
Post a Comment