AR25 · I Year I Semester · 2025–2026 · Unit V: Pointers and Strings
QUESTION 01 · Pointer Basics
A pointer is a value used to identify an object or function, or to represent a permitted special position such as a null pointer.
QUESTION 02 · Pointer Basics
A pointer variable stores a pointer value. A valid object pointer can be used to access an object indirectly.
int number = 10;
int *p = &number;&number produces the address of number. The declaration stores that address in p. The star in int *p declares a pointer type; it does not read the object at that point. The pointer and the pointed-to integer are separate objects.
In an expression, *p accesses the integer to which p points. Reading *p initially gives 10. Assigning *p = 25 changes number itself to 25. It does not change which object p identifies.
The program first prints the value through *p. It then assigns through *p and prints number. The second output is 25, demonstrating that direct access through number and indirect access through p reach the same object.
A direct pointer dereference and assignment to a fixed-size object take O(1) work in the usual model. A pointer does not automatically allocate the object it is expected to identify.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int main(void)
{
int number = 10;
int *p = &number;
printf("Before = %d\n", *p);
*p = 25;
printf("After = %d\n", number);
return 0;
}This example uses values already written in the program.
Before = 10
After = 25Related questions in the pointer basics category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
How is a pointer variable declared?
Paper P02 · page 1Define a pointer.
Paper P05 · page 1QUESTION 03 · Pointer Basics
No. A null pointer does not identify an object or function that can be accessed.
QUESTION 04 · Pointer Basics
A pointer’s type describes the kind of object or function it can identify and the operations permitted through it.
void * is a generic object-pointer type. In C, an object pointer can be converted to void * and back to its original object-pointer type, preserving the comparison result with the original. A void pointer cannot be directly dereferenced to obtain an object value, and standard C does not define arithmetic on void *. Convert it to the appropriate object-pointer type before suitable access.
NULL is a macro usable as a null pointer constant. A null pointer can mark that no object has been selected or allocation has failed. It is not safe to dereference. Do not assume its stored bit pattern or printed form must be all zeroes; use the language’s null-pointer operations.
The sample lets a void * hold the address of an int, then converts it back to int * and reads the integer. Both pointers identify the original live int object. This does not justify converting an arbitrary address to an unrelated type and reading it.
C does not require every pointer type to have the same size as int or even the same size as every other pointer type. Function pointers have their own types; void * is not a portable universal container for function pointers. Correct type, alignment and lifetime all matter.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int main(void)
{
int value = 12;
void *generic = &value;
int *p = generic;
printf("Value = %d\n", *p);
return 0;
}This example uses values already written in the program.
Value = 12Related questions in the pointer basics category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
How is a pointer variable declared?
Paper P02 · page 1Define a pointer.
Paper P05 · page 1QUESTION 05 · Pointers and Functions
No. The pointer value itself is passed by value.
QUESTION 06 · Pointers and Functions
A function can receive a pointer to a caller’s object and modify the object through that pointer.
void set_value(int *p, int value);number begins at 10. set_value(&number, 30) gives p the address of number and gives value the integer 30. The function checks p against NULL, then writes through it. After returning, main prints 30 because number itself was changed.
Changing p to NULL inside the function would only change the local pointer parameter. It would not replace a caller’s pointer variable. Changing *p updates the target. To update a caller’s pointer object, an additional level of indirection can be used, as shown in the pointer-to-pointer topic.
A non-null test is useful but does not prove every pointer is valid. The caller must still provide a pointer to a live, writable int object. A dangling pointer can be non-null. The example passes the address of a local object whose lifetime includes the complete call.
The function performs a fixed comparison and at most one fixed-size assignment. Time and auxiliary space are O(1). Passing an address does not require copying every byte of a larger object that might be reached through it.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void set_value(int *p, int value)
{
if (p != NULL) { *p = value; }
}
int main(void)
{
int number = 10;
set_value(&number, 30);
printf("Number = %d\n", number);
return 0;
}This example uses values already written in the program.
Number = 30Related questions in the pointer function arguments category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Explain passing pointers to a function, with examples.
Paper P09 · page 2QUESTION 07 · Pointers and Functions
pp is a pointer to an int * object.
QUESTION 08 · Pointers and Functions
A pointer to a pointer identifies another pointer object. It is useful when a function must update a caller’s pointer value.
int number = 10;
int *p = &number;
int **pp = &p;pp identifies p. Therefore *pp refers to p itself, and **pp reaches number. These levels must be interpreted in order. A declaration of int ** does not automatically create either a pointer target or an int target; all objects must already exist or be allocated appropriately.
redirect receives &p and &second. Its parameter slot identifies main’s pointer p. Assigning *slot = target changes p to identify second. After the call, *p reads 20. The function has changed which integer p points at, rather than assigning 20 into the first integer.
If the function received only a copy of p as int *local, assigning local = &second would change only local. Passing the address of p allows the function to reach and assign main’s actual pointer object. The argument is still passed by value: the copied value is now a pointer to that pointer object.
The slot must identify a live, writable int * object. A null check alone does not prove a non-null pointer is valid. The supplied target must also remain alive while it is used. The sample uses two local ints and one pointer during the same main call, so all lifetimes are suitable. Its fixed assignments use O(1) time and auxiliary space.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void redirect(int **slot, int *target)
{
if (slot != NULL) { *slot = target; }
}
int main(void)
{
int first = 10, second = 20;
int *p = &first;
redirect(&p, &second);
printf("Selected = %d\n", *p);
return 0;
}This example uses values already written in the program.
Selected = 20Related questions in the pointer function arguments category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Explain passing pointers to a function, with examples.
Paper P09 · page 2QUESTION 09 · Pointers and Functions
It declares a pointer to a function taking two int arguments and returning int.
QUESTION 10 · Pointers and Functions
A function pointer identifies a function with a compatible type and allows that function to be selected or passed as a value.
int (*operation)(int, int) = add;operation can identify a function receiving two ints and returning int. The function name add supplies a suitable function pointer in this expression. Calling operation(4, 6) or (*operation)(4, 6) invokes the selected function. The function must have a compatible type; an arbitrary cast does not make an incompatible call safe.
apply receives a function pointer named op along with a and b. It returns op(a, b). main supplies add for one call and subtract for another. Thus apply keeps the general calling step while the caller chooses the operation. The output is 10 for addition and -2 for subtraction.
Do not call a null or invalid function pointer. An object pointer and a function pointer are not interchangeable portable storage formats. The sample always passes real functions with exactly matching signatures.
An indirect call does not change the algorithmic growth of the selected function. With the fixed-size addition or subtraction shown, each application takes O(1) time and O(1) extra space. More complex callbacks can perform more work.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int apply(int (*op)(int, int), int a, int b)
{
return op(a, b);
}
int main(void)
{
printf("Add = %d\n", apply(add, 4, 6));
printf("Subtract = %d\n", apply(subtract, 4, 6));
return 0;
}This example uses values already written in the program.
Add = 10
Subtract = -2Related questions in the pointer function arguments category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Explain passing pointers to a function, with examples.
Paper P09 · page 2QUESTION 11 · Pointers and Arrays
It usually converts to a pointer to its first element.
QUESTION 12 · Pointers and Arrays
An array contains its elements, while a pointer can identify an element. Their close relationship makes pointer-based traversal possible, but they are not identical types.
int a[3] = {4, 5, 6};
int *p = a;For a valid index i, a[i] means *(a + i). With p pointing at the first element, p[i] and *(p + i) also access that element. The sample visits all three values through p and prints 4, 5 and 6.
A parameter written int a[] adjusts to int *a. That parameter does not retain the caller’s complete array length. Pass a suitable count separately and keep every access within the actual array.
A direct valid access takes O(1) time in the usual model. Traversing n elements through a pointer still takes O(n): pointer notation does not remove the need to visit every element. This traversal uses O(1) auxiliary space beyond the array.
| Feature | int a[3] | int *p |
|---|---|---|
| Stored object | Three contiguous int elements | One pointer value |
| Reassignment | Array not assignable as a whole | Pointer can be reassigned |
| sizeof on actual declaration | Entire array size | Pointer size |
| Length knowledge | Known from actual array type | Not carried by pointer alone |
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int main(void)
{
int a[3] = {4, 5, 6};
int *p = a;
for (int i = 0; i < 3; ++i) { printf("%d\n", *(p + i)); }
return 0;
}This example uses values already written in the program.
4
5
6Related questions in the pointers arrays category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
What is a pointer? Write a C program to sum array elements using a pointer.
Paper P03 · page 1QUESTION 13 · Pointers and Arrays
It moves to the next int element, not necessarily the next byte.
QUESTION 14 · Pointers and Arrays
Pointer arithmetic moves between elements of the same array. Its step is measured in elements of the pointed-to type.
If p identifies a[i], p + k can identify a[i + k] when the result is within that array or one past it. p - k moves backwards under the same restriction. p++ updates the pointer to the next element; (*p)++ instead increments the pointed-to value, when that value is writable and the operation is valid.
Subtracting two suitable pointers into the same array gives their distance in elements, of type ptrdiff_t. The sample sets first to a[0] and last to a[3], so last - first gives 3. Use %td to print ptrdiff_t. The difference must be representable in that type.
a + n can be formed for an array of n elements, but it must not be dereferenced. This permits a loop that stops when p equals the end pointer. Do not continue arithmetic beyond that position, even if an unrelated object happens to follow in memory.
A valid pointer step or difference is O(1) in the usual machine model. A loop that advances once per element still takes O(n) time and O(1) auxiliary space. The rules are about array membership, not merely whether an address appears numerically nearby.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <stddef.h>
int main(void)
{
int a[4] = {10, 20, 30, 40};
int *first = a, *last = a + 3;
printf("Next = %d\n", *(first + 1));
printf("Distance = %td\n", last - first);
return 0;
}This example uses values already written in the program.
Next = 20
Distance = 3Related questions in the pointer arithmetic category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write about pointer arithmetic operations.
Paper P05 · page 1QUESTION 15 · Pointers and Arrays
It declares an array of three pointers to const char.
QUESTION 16 · Pointers and Arrays
An array of pointers stores several pointer values. Each element can identify a different object or string.
const char *names[3] = {"C", "Python", "Java"};names[0] points to the first character of "C", names[1] to "Python" and names[2] to "Java". Each names[i] is a pointer, not an entire fixed-width row of characters. The string literals exist separately and must not be modified.
puts(names[i]) displays the selected null-terminated string and adds a newline. names[i][j] can read the j-th character when that index is valid for the selected string. The null terminator belongs to each separate string; it does not terminate the array of pointers itself.
char names[3][10] reserves three rows of ten characters, including room for each terminator. const char *names[3] reserves three pointers that identify existing strings of potentially different lengths. The layouts and parameter types differ. An array of pointers is not automatically one contiguous character matrix.
Pointer arrays are useful for menus, labels or lists of independently stored strings. Selecting names[i] takes O(1) work. Displaying all characters takes time proportional to the total displayed string length, plus the list traversal. The pointer array needs storage for three pointers in this fixed example; the strings have their own storage.
The const applies to the characters reached through each pointer. It does not by itself make each pointer element impossible to reassign to another suitable string.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int main(void)
{
const char *names[3] = {"C", "Python", "Java"};
for (int i = 0; i < 3; ++i) { puts(names[i]); }
return 0;
}This example uses values already written in the program.
C
Python
JavaRelated questions in the array of pointers category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
What do you mean by an array of pointers?
Paper P02 · page 1QUESTION 17 · Pointers and Arrays
int (*)[3], a pointer to an array of three int.
QUESTION 18 · Pointers and Arrays
A two-dimensional array is an array of row arrays. Its usual conversion produces a pointer to its first row, not a pointer to pointer.
int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
int (*p)[3] = a;p identifies the first row. p + 1 identifies the next row because its pointed-to type is an array of three ints. p[1][2] reads 6. The equivalent form *(*(p + 1) + 2) first selects the second row and then its third element.
The compiler needs the row width to calculate the correct step between rows. A function parameter int a[][3] adjusts to this pointer-to-row type. Passing a logical column count does not change an actual object declared with a different fixed row width.
An int ** identifies an int * object. A rectangular int a[2][3] instead contains ints grouped into row arrays; it does not contain an intermediate array of int * values. Casting between these layouts does not rearrange the storage and does not justify incompatible access.
Both row and column indices must be valid. a[0][3] is not a permitted replacement for a[1][0]. Reading a fixed valid element takes O(1) work. Traversing all r × c elements takes O(rc) time and O(1) auxiliary space beyond the matrix. The example reads one element and displays its value.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
int main(void)
{
int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
int (*p)[3] = a;
printf("Selected = %d\n", *(*(p + 1) + 2));
return 0;
}This example uses values already written in the program.
Selected = 6Related questions in the pointers arrays category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
What is a pointer? Write a C program to sum array elements using a pointer.
Paper P03 · page 1QUESTION 19 · Dynamic Memory
stdlib.h declares these allocation and release functions.
QUESTION 20 · Dynamic Memory
Dynamic allocation requests storage while a program is running. The program manages the useful lifetime of that storage explicitly.
int *p = malloc(n * sizeof *p);sizeof *p gives the size of the intended element without evaluating a dereference in this ordinary int case. In C, the returned void * can be assigned to int * without a cast. The allocated object is not automatically released when the local pointer variable leaves scope. Losing the last useful pointer to a needed allocation can cause a memory leak.
Storage for n integers is proportional to n, giving O(n) allocated space. Initialising or reading all n elements takes O(n) work. C does not specify one algorithm or universal Big-O bound for malloc itself, so do not claim that every allocation call is guaranteed constant time. The following topics supply complete examples.
Related questions in the dynamic memory category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write a note on dynamic memory allocation.
Paper P01 · page 1Write the syntax of malloc().
Paper P02 · page 1QUESTION 21 · Dynamic Memory
malloc leaves allocated contents uninitialised; calloc sets all allocated bytes to zero.
QUESTION 22 · Dynamic Memory
Both functions obtain allocated storage, but their argument forms and initialisation differ.
int *a = malloc(n * sizeof *a);int *b = calloc(n, sizeof *b);malloc takes one byte-count argument. calloc takes an element count and an element size. A successful call returns a suitably aligned pointer for the ordinary int objects used here. A failed non-zero request returns NULL. Always check the result before access.
The program requests three ints with each function. It explicitly fills the malloc block with 1, 2 and 3, so their sum is 6. It then reads the calloc-created int elements, whose initial values are zero, and prints a sum of 0. Both blocks are freed.
The all-zero-byte rule is not a universal promise of the floating value 0.0 or a null pointer representation for every type. The example specifically uses int. For arbitrary counts, validate multiplication before forming a malloc byte count; do not allow size_t arithmetic to wrap. This fixed request has a small known count.
If either allocation fails, the sample frees any successful allocation before returning. free(NULL) is permitted. Filling and summing n elements requires O(n) element work, and the allocated storage is O(n). Allocator internals have implementation-dependent costs; the traversal analysis is separate.
| Feature | malloc | calloc |
|---|---|---|
| Arguments | Byte count | Element count and size |
| Initial contents | Not initialised | All allocated bytes zeroed |
| Failure of non-zero request | NULL | NULL |
| Release | free | free |
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
size_t n = 3;
int *a = malloc(n * sizeof *a);
int *b = calloc(n, sizeof *b);
if (a == NULL || b == NULL) {
free(a); free(b); puts("Allocation failed"); return 1;
}
int sum_a = 0, sum_b = 0;
for (size_t i = 0; i < n; ++i) {
a[i] = (int)i + 1;
sum_a += a[i]; sum_b += b[i];
}
printf("Malloc sum = %d, calloc sum = %d\n", sum_a, sum_b);
free(a); free(b);
return 0;
}This example uses values already written in the program.
Malloc sum = 6, calloc sum = 0Related questions in the dynamic memory category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write a note on dynamic memory allocation.
Paper P01 · page 1Write the syntax of malloc().
Paper P02 · page 1QUESTION 23 · Dynamic Memory
If a non-zero reallocation fails, NULL is returned and the original block remains allocated.
QUESTION 24 · Dynamic Memory
realloc changes an allocation’s size. free releases storage obtained through the allocation family.
int *temporary = realloc(p, new_count * sizeof *p);
if (temporary == NULL) {
/* p still identifies the original block for this non-zero request */
} else {
p = temporary;
}On success, the old contents are preserved up to the smaller of the old and new sizes. A larger block’s added bytes are not automatically initialised. The allocation may move. The old pointer must no longer be used after a successful realloc, even when the returned address appears unchanged.
The sample allocates two ints and stores 1 and 2. It requests space for four ints using a temporary pointer. After success, it stores 3 and 4 in the new positions and displays 1, 2, 3, 4. If growth fails, it frees the still-valid original block and exits.
Pass free a valid currently allocated base pointer, or NULL. Do not free an interior element pointer, an automatic array or the same allocation twice. After freeing p, assigning p = NULL avoids retaining a dangling value in that variable. Other aliases are not automatically changed.
Use a validated non-zero new size and check multiplication for overflow. This lesson avoids the special zero-size realloc cases. A reallocation may need to copy retained data; its allocator cost is implementation-dependent. The explicit initialisation and printing of n values take O(n) work, and storage for n ints is O(n).
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *p = malloc(2 * sizeof *p);
if (p == NULL) { puts("Allocation failed"); return 1; }
p[0] = 1; p[1] = 2;
int *temporary = realloc(p, 4 * sizeof *p);
if (temporary == NULL) { free(p); puts("Allocation failed"); return 1; }
p = temporary;
p[2] = 3; p[3] = 4;
for (int i = 0; i < 4; ++i) { printf("%d\n", p[i]); }
free(p);
p = NULL;
return 0;
}This example uses values already written in the program.
1
2
3
4Related questions in the dynamic memory category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write a note on dynamic memory allocation.
Paper P01 · page 1Write the syntax of malloc().
Paper P02 · page 1QUESTION 25 · Dynamic Memory
A dangling pointer refers to storage whose lifetime has ended. A memory leak leaves allocated storage without the intended means of releasing it.
QUESTION 26 · Dynamic Memory
Pointer safety requires a valid target, correct bounds and a suitable lifetime. A pointer-looking value alone is not proof that access is allowed.
An ordinary automatic pointer declared without an initialiser does not contain a useful guaranteed pointer value. Do not read or dereference it. Initialise it to a valid address or a null pointer according to its intended state.
A pointer becomes unusable for target access when that object’s lifetime ends. Examples include a pointer to an automatic local array after its function returns and a pointer into a freed allocation. A non-null check does not establish that either target is still alive.
If the last useful pointer to an allocated block is lost before free, the program may no longer be able to release it. Overwriting p directly with a failed realloc result is a common source of this mistake. Use a temporary result for non-zero reallocation.
An index or pointer must remain within the appropriate object. A formed one-past-end pointer is not a valid element to dereference. String routines also require reachable termination and enough writable destination capacity. Merely changing a pointer’s type does not create a larger object.
These are correctness rules, not optional optimisations. An invalid access has undefined behaviour; passing a small test does not make the access valid.
A student stores three marks in a dynamically allocated array and later needs room for five. A successful realloc may move the block. For a non-zero requested size, a failed realloc returns a null pointer and leaves the original block allocated.
| Result | What happens to the data? | What should the program do? |
|---|---|---|
| Success | The first three integers are preserved; the added space is uninitialised | Assign the returned pointer to items, then initialise the two new elements |
| Failure | The original three-element block remains allocated | Keep its pointer for later use, or free it before returning |
Writing items = realloc(items, ...) directly can overwrite the only useful pointer with a null pointer on failure. Save the result in a temporary pointer first. After success, use the returned pointer; any old aliases to the previous allocation must not be used, even if the returned address appears unchanged.
This example uses fixed sizes of three and five integers. It frees the original block if resizing fails because the program is about to exit.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *items = malloc(3 * sizeof *items);
if (items == NULL) {
puts("Allocation failed");
return 1;
}
for (int i = 0; i < 3; ++i) { items[i] = (i + 1) * 10; }
printf("Before: %d %d %d\n", items[0], items[1], items[2]);
int *temporary = realloc(items, 5 * sizeof *items);
if (temporary == NULL) {
/* The original block is still available through items. */
free(items);
puts("Resize failed");
return 1;
}
items = temporary;
items[3] = 40;
items[4] = 50;
printf("After: %d %d %d %d %d\n",
items[0], items[1], items[2], items[3], items[4]);
free(items);
items = NULL;
return 0;
}
Before: 10 20 30
After: 10 20 30 40 50The program writes elements 3 and 4 before reading them. Increasing capacity does not automatically give those new integers useful values. If a real program accepts a size from input, it must also check that the size multiplication fits in size_t before allocating.
Related questions in the dynamic memory category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write a note on dynamic memory allocation.
Paper P01 · page 1Write the syntax of malloc().
Paper P02 · page 1QUESTION 27 · String Basics
A null character, written '\0', marks its end.
QUESTION 28 · String Basics
A C string is a sequence of character bytes terminated by a null character. A character array is a string only when the required terminator is present within its valid storage.
char word[] = "Code";
/* elements: C, o, d, e, \0 */word contains five char elements, so sizeof word is 5 C bytes. Its string length is 4 because strlen counts characters before the terminator. A destination for four visible ASCII characters needs at least five char positions. The terminator occupies space even though it is not printed as part of the text.
char word[] = "Code"; creates a writable array initialised from the literal. const char *label = "Code"; creates a pointer to a string literal that must not be modified. The array and the pointer have different sizes and assignment rules.
Finding the length with strlen requires examining bytes until the terminator, giving O(n) work in the ordinary analysis. A known-index character read is O(1). These introductory examples process ordinary text bytes; a byte count is not necessarily the count of displayed Unicode characters in a multibyte encoding.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int main(void)
{
char word[] = "Code";
printf("Length = %zu, array bytes = %zu\n", strlen(word), sizeof word);
return 0;
}This example uses values already written in the program.
Length = 4, array bytes = 5Related questions in the string basics category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Differentiate a null-terminated string and a fixed-length string.
Paper P06 · page 1Compare character arrays and string literals. Explain strings as arrays of characters.
Paper P08 · page 1QUESTION 29 · String Basics
It reads a bounded sequence of characters and can include spaces.
QUESTION 30 · String Basics
fgets reads at most one less than the supplied positive capacity and adds a null terminator when successful. It is useful for whole-line input, including spaces.
char line[80];
if (fgets(line, sizeof line, stdin) != NULL) {
/* use the successfully read string */
}If the newline fits, fgets stores it before the terminator. strchr(line, '\n') can locate it so that it can be replaced with '\0'. Do not simply delete the last stored character without checking: input can end without a newline.
This complete example accepts at most 79 text bytes. Its helper reads a bounded first portion. If no newline was stored, it checks the next input character: a newline or end of input means the line fit exactly or ended naturally. A longer line is drained and rejected, preventing a truncated prefix from being accepted as the whole answer.
A failed read must be handled before treating the buffer as new input. gets must not be used because it cannot enforce the destination capacity and is not part of modern standard C. scanf("%s", ...) stops at whitespace and is not equivalent to whole-line input.
Reading and checking a line of n bytes takes O(n) work. This fixed buffer uses bounded storage; a general capacity-m version needs O(m) buffer space. The helper is for ordinary text without embedded null bytes, not arbitrary binary input.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int read_line(char s[], int capacity)
{
if (fgets(s, capacity, stdin) == NULL) { return 0; }
char *newline = strchr(s, '\n');
if (newline != NULL) { *newline = '\0'; return 1; }
int ch = getchar();
if (ch == '\n' || ch == EOF) { return 1; }
while ((ch = getchar()) != '\n' && ch != EOF) { }
return 0;
}
int main(void)
{
char line[80];
if (!read_line(line, 80)) { puts("Invalid or overlong input"); return 1; }
printf("Line: %s\n", line);
return 0;
}Hello studentsLine: Hello studentsRelated questions in the string basics category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Differentiate a null-terminated string and a fixed-length string.
Paper P06 · page 1Compare character arrays and string literals. Explain strings as arrays of characters.
Paper P08 · page 1QUESTION 31 · String Basics
It prevents modification through that parameter’s character access.
QUESTION 32 · String Basics
A character pointer can identify the first byte of a string. Functions can use it to read characters or, for a writable target and suitable interface, modify them.
void show(const char *text);The caller supplies a pointer to the first character. show reads text until its null terminator through puts. The const-qualified character access prevents the function from writing text[0] through this parameter. The local pointer parameter itself is a copied pointer value.
A literal such as "Welcome" must not be modified. A writable array such as char name[] = "Student"; contains its own copy and can be changed within bounds. Both can be passed to a suitable reading function. Use const char * for a literal pointer so the intended reading-only use is clear.
A function that writes a string normally needs char * and a destination capacity. The pointer alone does not communicate how many positions are available. A function must not store beyond the capacity or leave a result unterminated when a string result is promised.
Returning a pointer is valid only when the target remains alive for its later use. Do not return the address of an ordinary automatic local character array. A pointer to caller-owned storage or a suitable lasting object requires a clearly stated lifetime and ownership agreement.
Displaying n bytes takes O(n) output work. The pointer argument is small fixed-size state and does not copy the whole string. No new variable-length buffer is created by this example.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
void show(const char *text)
{
puts(text);
}
int main(void)
{
show("Welcome");
return 0;
}This example uses values already written in the program.
WelcomeRelated questions in the string basics category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Differentiate a null-terminated string and a fixed-length string.
Paper P06 · page 1Compare character arrays and string literals. Explain strings as arrays of characters.
Paper P08 · page 1QUESTION 33 · String Operations
strlen finds length, strcpy copies, strcat appends and strcmp compares strings.
QUESTION 34 · String Operations
The string.h header declares common operations on null-terminated strings and memory. Each function still requires valid arguments and sufficient storage.
strcpy needs enough writable destination positions for source length plus one. strcat needs enough for both lengths plus one, and destination must already contain a valid string. These functions do not receive the destination’s capacity and cannot automatically grow it.
strcpy and strcat require non-overlapping source and destination strings. For overlapping regions within one array, memmove is designed for moving a specified byte count safely. strncpy is not a general guarantee of termination: if the source is at least the specified count, the copied result is not automatically terminated.
Use strcmp rather than == to compare text contents. Check only its result’s sign, not an assumed exact -1 or 1. Use %zu for the size_t returned by strlen. The length excludes the terminator, while required storage includes it.
strlen and strcpy perform work proportional to the relevant string length. A single strcat must find the destination end and copy the source, giving O(d + s) work. strcmp examines a prefix until a difference or end is reached, up to O(min(m, n) + 1) byte comparisons. No growing auxiliary array is required by these basic operations.
| Function | Purpose | Key requirement |
|---|---|---|
| strlen | Count bytes before terminator | Valid terminated source |
| strcpy | Copy with terminator | Enough capacity; no overlap |
| strcat | Append source | Terminated destination; enough space; no overlap |
| strcmp | Compare contents | Both sources terminated |
| strchr | Find character | Valid terminated source |
| memmove | Move specified byte count | Valid source/destination ranges; overlap allowed |
Related questions in the string functions category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Describe string library functions with syntax and an example program.
Paper P01 · page 1Explain strcat and strcpy with examples.
Paper P02 · page 1QUESTION 35 · String Operations
Ordinary arrays are not assignable as whole objects using =.
QUESTION 36 · String Operations
A string can be used to initialise a character array, but replacing that array’s contents later requires copying characters into its writable storage.
char destination[20] = "Hello";strcpy(destination, source) copies the characters and terminator when the destination is large enough and the regions do not overlap. The sample checks strlen(source) against sizeof destination before copying. It then prints the new contents C programming.
With const char *p = "Hello"; and p = "C";, only the pointer value changes. No characters are copied into the earlier string. This is valid pointer reassignment to another literal, but the literals themselves must not be modified.
A source of length 13 needs 14 char positions including the terminator. A 20-position destination can hold it. The comparison uses source length < destination capacity, not <=, because one position is reserved for the terminator.
Do not apply sizeof destination as a capacity calculation when destination is merely an adjusted array parameter; pass the capacity separately. Do not assume strncpy always makes a usable string. If a manual copy is used, ensure it copies or writes the terminator too.
Checking the length scans n source bytes, and copying scans them again. The total remains O(n), since a fixed number of linear passes is still linear. The copy writes into an existing buffer, with O(1) auxiliary space beyond that destination.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int main(void)
{
char destination[20] = "Hello";
const char *source = "C programming";
if (strlen(source) >= sizeof destination) { puts("Too long"); return 1; }
strcpy(destination, source);
puts(destination);
return 0;
}This example uses values already written in the program.
C programmingRelated questions in the string functions category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Describe string library functions with syntax and an example program.
Paper P01 · page 1Explain strcat and strcpy with examples.
Paper P02 · page 1QUESTION 37 · String Operations
Its start must be at most the source length, and its count must be at most length - start.
QUESTION 38 · String Operations
A substring is a consecutive part of a string. This example uses a zero-based start index and a requested character count.
For source "Programming", start 3 selects the first g. Taking count 4 copies g, r, a and m, producing "gram". The extracted text must receive its own terminator; it cannot depend on the next source character being null.
start equal to the source length is valid only when count is zero. The result is an empty string. A request extending beyond the end is rejected. Testing count against length - start after validating start avoids adding start + count unnecessarily.
The sample uses a separate output array, so source and destination do not overlap. An interface should state its capacity and bounds clearly. C does not provide a special substring assignment operator that automatically allocates and terminates a result.
The strlen pass takes O(n) for source length n. Copying k requested characters takes O(k), so the complete function is O(n + k), which is O(n) for a valid k <= n. Output storage needs O(k + 1) positions, while counters add O(1) auxiliary space. A function receiving a known validated source length could avoid scanning it again.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int substring(const char *s, size_t start, size_t count, char out[], size_t capacity)
{
size_t length = strlen(s);
if (start > length || count > length - start || capacity == 0 || count >= capacity) { return 0; }
for (size_t i = 0; i < count; ++i) { out[i] = s[start + i]; }
out[count] = '\0';
return 1;
}
int main(void)
{
char result[20];
if (!substring("Programming", 3, 4, result, sizeof result)) { puts("Invalid request"); return 1; }
puts(result);
return 0;
}This example uses values already written in the program.
gramRelated questions in the substring operations category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write a C program to insert a substring into a main string from a given position.
Paper P02 · page 1What does strstr() do?
Paper P05 · page 1QUESTION 39 · String Operations
At least m + n + 1 char positions are required.
QUESTION 40 · String Operations
Concatenation appends one string to another. strcat places the source characters after the destination’s current text and writes a final terminator.
strcat(destination, source);destination starts as "Hello " in a 30-position array. source is "students". Their lengths are 6 and 8, so the result has length 14 and requires 15 positions. The check confirms the source fits in the remaining space, then strcat produces "Hello students".
After confirming the existing destination is a valid string in its array, remaining capacity for new non-null bytes is capacity - used - 1. Comparing the added length with that remainder avoids an unchecked sum. The sample uses sizeof destination where the actual array is visible.
For destination length m and source length n, strcat first locates the existing end and then copies the new text, giving O(m + n) work in the usual analysis. Length checks add only another fixed number of scans. Auxiliary space is O(1) beyond the destination buffer. Repeatedly appending many tiny pieces can cause repeated rescanning of a growing prefix and become quadratic in total work.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int main(void)
{
char destination[30] = "Hello ";
const char *source = "students";
size_t used = strlen(destination), added = strlen(source);
if (added > sizeof destination - used - 1) { puts("Too long"); return 1; }
strcat(destination, source);
puts(destination);
return 0;
}This example uses values already written in the program.
Hello studentsRelated questions in the string functions category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Describe string library functions with syntax and an example program.
Paper P01 · page 1Explain strcat and strcpy with examples.
Paper P02 · page 1QUESTION 41 · String Operations
Negative means the first string sorts before the second, zero means equal contents, and positive means after.
QUESTION 42 · String Operations
strcmp compares two null-terminated strings lexicographically, examining their contents rather than comparing pointer values.
strcmp("Code", "Code") returns zero. The sample therefore prints Equal. Comparing a string with a longer string that starts with the same prefix treats the shorter completed prefix as earlier, since its null terminator is compared at that position.
For pointer expressions referring to strings, == compares pointer values. Two pointers can identify different arrays containing equal text. Conversely, sharing one pointer does not perform a character-by-character text comparison. Use strcmp when the question is whether the stored text is equal.
strcmp is case-sensitive and is not a general dictionary-order comparison for every language or locale. The exact encoding influences byte values. Do not hard-code an expected difference such as -32; inspect only the sign. For these introductory examples, use ordinary byte strings with valid termination.
The function stops at the first difference or a terminating position. It may finish in O(1) for a first-byte difference, and needs up to O(min(m, n) + 1) byte comparisons for lengths m and n. It needs no growing output array, giving O(1) auxiliary space in the usual analysis.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int main(void)
{
char a[] = "Code", b[] = "Code";
int result = strcmp(a, b);
if (result == 0) { puts("Equal"); }
else if (result < 0) { puts("First is earlier"); }
else { puts("First is later"); }
return 0;
}This example uses values already written in the program.
EqualRelated questions in the string functions category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Describe string library functions with syntax and an example program.
Paper P01 · page 1Explain strcat and strcpy with examples.
Paper P02 · page 1QUESTION 43 · String Operations
No. It counts the bytes before the terminator.
QUESTION 44 · String Operations
A manual length function scans from the first character until the terminating null character is reached.
For "Code", index 0 contains C, index 1 contains o, index 2 contains d and index 3 contains e. Each adds one to length. At index 4 the null character is found, so the returned length is 4.
size_t is suitable for an object or string size. The sample obtains its declaration through stddef.h and prints it with %zu. It does not assume every valid string length fits int.
The pointer must identify a valid string with a terminator reachable inside its permitted object. Without that terminator, the loop could read out of bounds; using a pointer or a library function does not repair an invalid string. A null pointer is not an empty string and cannot be passed here.
An empty string starts with the terminator, so the loop runs zero times and returns zero. Spaces are counted like other non-null bytes. A multibyte encoded character may occupy several bytes, so this result is a byte-string length rather than a universal displayed-character count.
For n non-null bytes, the loop makes n increments and a final stopping test. Time is O(n). It stores only the counter and pointer parameter, giving O(1) auxiliary space. The source is not modified or duplicated.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <stddef.h>
size_t text_length(const char *s)
{
size_t length = 0;
while (s[length] != '\0') { ++length; }
return length;
}
int main(void)
{
printf("Length = %zu\n", text_length("Code"));
return 0;
}This example uses values already written in the program.
Length = 4Related questions in the string functions category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Describe string library functions with syntax and an example program.
Paper P01 · page 1Explain strcat and strcpy with examples.
Paper P02 · page 1QUESTION 45 · Substring Editing
The suffix from the insertion position, including its terminator, must move right.
QUESTION 46 · Substring Editing
Substring insertion places new text inside a writable string while preserving the text before and after the insertion position.
The main string is "CodeBhavya". Position 4 is immediately after Code. Inserting one space produces "Code Bhavya". The suffix Bhavya and the terminator move one position right before the space is copied into the gap.
The source and destination suffixes are parts of the same array and can overlap. memmove supports that case. memcpy is used for the separate inserted string bytes here; the function requires the inserted source to be separate from the destination storage. It is not intended to insert an overlapping slice of itself.
Position equal to the length appends text. Position zero inserts at the beginning. An empty inserted string leaves the contents unchanged. The function first checks length < capacity, then compares added length with capacity - length - 1, reserving a terminator position.
Finding both lengths takes O(n + m). Moving the suffix takes at most O(n), and copying the new text takes O(m). Total work is O(n + m). The result needs capacity for n + m + 1 bytes; the explicit algorithm uses only fixed-size counters beyond that caller-owned buffer.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int insert_text(char *s, size_t capacity, size_t position, const char *part)
{
size_t length = strlen(s), added = strlen(part);
if (position > length || length >= capacity || added > capacity - length - 1) { return 0; }
memmove(s + position + added, s + position, length - position + 1);
memcpy(s + position, part, added);
return 1;
}
int main(void)
{
char text[40] = "CodeBhavya";
if (!insert_text(text, sizeof text, 4, " ")) { puts("Invalid request"); return 1; }
puts(text);
return 0;
}This example uses values already written in the program.
Code BhavyaRelated questions in the substring operations category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write a C program to insert a substring into a main string from a given position.
Paper P02 · page 1What does strstr() do?
Paper P05 · page 1QUESTION 47 · Substring Editing
Move the surviving suffix left over the deleted region, including the terminator.
QUESTION 48 · Substring Editing
Substring deletion removes a chosen count of consecutive characters and joins the remaining prefix and suffix.
For "Code Bhavya", position 4 identifies the space and count 1 removes it. The suffix Bhavya moves left over that space, followed by its terminator. The result is "CodeBhavya".
A zero count leaves the text unchanged. Deleting the entire string from position zero produces an empty string. Deleting a suffix leaves a terminator at the deletion start. A start equal to the length is allowed only with a zero count.
A string must remain consecutive from its beginning to its terminator. Simply replacing deleted positions with spaces would change the contents but not perform the requested deletion. Writing a terminator at the start would discard the whole suffix, which is also a different operation.
The move happens inside the existing writable array, and deletion never increases the length. memmove handles the overlapping source and destination. The original argument must already be a valid string; the function does not search beyond arbitrary invalid storage safely.
The initial length scan is O(n), and the moved suffix is at most n + 1 bytes. Total time is O(n), with fixed-size explicit counters and no separate result buffer. The operation changes the caller’s original string.
/* CodeBhavya | PPS AR25 | Learning example */
#include <stdio.h>
#include <string.h>
int delete_text(char *s, size_t position, size_t count)
{
size_t length = strlen(s);
if (position > length || count > length - position) { return 0; }
memmove(s + position, s + position + count, length - position - count + 1);
return 1;
}
int main(void)
{
char text[] = "Code Bhavya";
if (!delete_text(text, 4, 1)) { puts("Invalid request"); return 1; }
puts(text);
return 0;
}This example uses values already written in the program.
CodeBhavyaRelated questions in the substring operations category from the supplied papers. The marks below are the printed allocations, including any combined subquestion.
Write a C program to insert a substring into a main string from a given position.
Paper P02 · page 1What does strstr() do?
Paper P05 · page 1