Pointers: Parameter

Passing and Return

1
Passing Pointers to a Function
 Pointers are often passed to a function as
arguments
 Allows data items within the calling function to be
accessed by the called function, altered, and then
returned to the calling function in altered form
 Useful for returning more than one value from a
function
 Still call-by-value, but now the address is copied,
not the content

2
Example: Swapping
int main()
{
int a, b;
a = 5; b = 20;
swap (a, b);
printf (“\n a=%d, b=%d”, a, b); Output
return 0; a=5, b=20
}
Parameters
void swap (int x, int y) passed by
{ value, so
int t; changes done
t = x; on copy, not
x = y; returned to
y = t; calling
} function
3
Example: Swapping using pointers
int main()
{
int a, b;
a = 5; b = 20; Output
swap (&a, &b);
printf (“\n a=%d, b=%d”, a, b); a=20, b=5
return 0;
}
Parameters
void swap (int *x, int *y) passed by
{ address,
int t; changes done
t = *x; on the value
*x = *y; stored at that
*y = t; address,
correctly
}
swapped
4
 While passing a parameter to a function, when
should you pass its address instead of the
value?
 Pass address if both these conditions are satisfied
 The parameter value will be modified inside the function body
 The modified value is needed in the calling function after the
called function returns
 Consider the swap function to see this

5
 Passing Arrays as Pointers
Both the forms below are fine in the function body, as
arrays are passed by passing the address of the first
element. Calling function calls it the same way
int main() int main()
{ {
int n; int n;
float list[100], avg; float list[100], avg;
: :
avg = average (n, list); avg = average (n, list);
: :
} }

float average (int a, float x[]) float average (int a, float *x)
{ {
: :
sum = sum + x[i]; sum = sum + x[i];
} } 6
Returning multiple values from a
function
 Return statement can return only one value
 What if we want to return more than one value?
 Use pointers
 Return one value as usual with a return statement
 For other return values, pass the address of a
variable in which the value is to be returned

7
 Example: Returning max and min
of an array
Both returned through pointers (could have returned one of
them through return value of the function also)
int main()
{ void MinMax(int A[], int n, int
int n, min, max, i, A[100]; *min, int *max)
scanf(“%d”, &n); {
for (i=0; i<n; ++i) int i, x, y;
scanf(“%d”, &A[i]); x = y = A[0];
MinMax(A, n, &min, &max); for (i=1; i<n; ++i) {
printf(“Min and max are %d, if (A[i] < x) x = A[i];
%d”, min, max); if (A[i] > y) y = A[i];
return 0; }
} *min = x; *max = y;
}
8
 Example: Passing structure pointers
struct complex {
float re; void add (struct complex
float im; *x, struct complex *y,
struct complex *t)
};
{
t->re = x->re + y->re;
int main()
t->im = x->im + y->im;
{
}
struct complex a, b, c;
scanf(“%f%f”, &a.re, &a.im);
scanf(“%f%f”, &b.re, &b.im); The program will print the
add(&a, &b, &c) ; sum of a and b correctly.
printf(“\n %f %f”, c.re, Just try passing a, b, c
c.im); directly (no pointers in call
return 0; or in function declaration)
} and see what happens
9
Strings

10
Strings
• 1-d arrays of type char
• By convention, a string in C is terminated by the
end-of-string sentinel ‘\0’ (null character)
• char s[21] - can have variable length string
delimited with \0
• Max length of the string that can be stored is 20 as
the size must include storage needed for the ‘\0’
• String constants : “hello”, “abc”
• “abc” is a character array of size 4

11
String Constant
• A string constant is treated as a pointer
• Its value is the base address of the string
char *p = “abc”;

p a b c \0

printf (“%s %s\n”,p,p+1); /* abc bc is printed */

12
 Differences : array & pointers
char *p = “abcde”; char s[ ] = “abcde”;
The compiler allocates ≡ char s[ ] = {‘a’,’b’,’c’,’d’,’e’.’\0’};
space for p, puts the
string constant “abcde” The compiler allocates 6 bytes
in memory somewhere of memory for the array s
else, initializes p with which are initialized with the
the base address of 6 characters
the string constant

p
S a b c d e \0
a b c d e \0
13
Library Functions for String
Handling
 You can write your own C code to do different
operations on strings like finding the length of a
string, copying one string to another, appending
one string to the end of another etc.
 C library provides standard functions for these
that you can call, so no need to write your own
code
 To use them, you must do
#include <string.h>
At the beginning of your program (after #include
<stdio.h>)
14
String functions we will see
 strlen : finds the length of a string
 strcat : concatenates one string at the end of
another
 strcmp : compares two strings lexicographically
 strcpy : copies one string to another

15
strlen() You cannot change contents
of s in the function

int strlen(const char *s)

 Takes a null-terminated
strings (we routinely refer int strlen (const char *s) {
to the char pointer that int n;
points to a null-terminated for (n=0; *s!=‘\0’; ++s)
char array as a string) ++n;
return n;
 Returns the length of
}
the string, not counting
the null (\0) character

16
 strcat() You cannot change contents
of s2 in the function
 char *strcat (char *s1,
const char *s2); char *strcat(char *s1, const char
 Takes 2 strings as *s2)
arguments, {
concatenates them, char *p = s1;
while (*p != ‘\0’) /* go to end */
and puts the result in
++p;
s1. Returns s1. while(*s2 != ‘\0’)
Programmer must *p++ = *s2++; /* copy */
ensure that s1 points *p = ‘\0’;
to enough space to return s1;
hold the result. }

17
Dissection of the strcat() function
char *p = s1;
p is being initialized, not *p. The pointer p is initialized
to the pointer value s1. Thus p and s1 point to the
same memory location

18
Dissection of the strcat() function
char *p = s1;
p is being initialized, not *p. The pointer p is initialized
to the pointer value s1. Thus p and s1 point to the
same memory location
while (*p != ‘\0’) ++p;
As long as the value pointed to by p is not ‘\0’, p is
incremented, causing it to point at the next
character in the string. When p points to \0, the
control exits the while statement

19
Dissection of the strcat() function
char *p = s1;
p is being initialized, not *p. The pointer p is initialized
to the pointer value s1. Thus p and s1 point to the
same memory location
while (*p != ‘\0’) ++p;
As long as the value pointed to by p is not ‘\0’, p is
incremented, causing it to point at the next
character in the string. When p points to \0, the
control exits the while statement
while(*s2 != ‘\0’) *p++ = *s2++; /* copy */
At the beginning, p points to the null character at the
end of string s1. The characters in s2 get copied
one after another until end of s2

20
Dissection of the strcat() function
char *p = s1;
p is being initialized, not *p. The pointer p is initialized
to the pointer value s1. Thus p and s1 point to the
same memory location
while (*p != ‘\0’) ++p;
As long as the value pointed to by p is not ‘\0’, p is
incremented, causing it to point at the next
character in the string. When p points to \0, the
control exits the while statement
while(*s2 != ‘\0’) *p++ = *s2++; /* copy */
At the beginning, p points to the null character at the
end of string s1. The characters in s2 get copied
one after another until end of s2
*p = ‘\0’; put the ‘\0’ at the end of the string
21
 strcmp()
int strcmp (const char
*s1, const char *s2);
Two strings are passed
as arguments. An
integer is returned
that is less than,
equal to, or greater
than 0, depending on
whether s1 is
lexicographically less
than, equal to, or
greater than s2.
22
 strcmp() int strcmp(char *s1, const char *s2)
{
int strcmp (const char for (;*s1!=‘\0’&&*s2!=‘\0’; s1++,s2++)
*s1, const char *s2); {
if (*s1>*s2) return 1;
Two strings are passed if (*s2>*s1) return -1;
as arguments. An }
integer is returned if (*s1 != ‘\0’) return 1;
that is less than, if (*s2 != ‘\0’) return -1;
equal to, or greater return 0;
}
than 0, depending on
whether s1 is Important: When you use strcmp() from
lexicographically less the string library, check the return value for
>, < or = 0, not for +1, -1, and 0 (which are
than, equal to, or just one possible return value to satisfy the
greater than s2. >, <, and = 0 condition
23
 strcpy()
char *strcpy (char *s1, char *s2);
The characters is the string s2 are copied into s1 until
\0 is moved. Whatever exists in s1 is overwritten. It is
assumed that s1 has enough space to hold the
result. The pointer s1 is returned.

24
 strcpy()
char *strcpy (char *s1, const char *s2);
The characters is the string s2 are copied into s1 until
‘\0’ is moved. Whatever exists in s1 is overwritten. It
is assumed that s1 has enough space to hold the
result. The pointer s1 is returned.

char * strcpy (char *s1, const char *s2)

{
char *p = s1;
while (*p++ = *s2++) ;
return s1;
}
25
 Example: Using string functions
int main()
{
char s1[ ] = "beautiful big sky country", Output
s2[ ] = "how now brown cow";
25
printf("%d\n",strlen (s1));
printf("%d\n",strlen (s2+8)); 9
printf("%d\n", strcmp(s1,s2)); -1
printf("%s\n",s1+10); big sky country
strcpy(s1+10,s2+8); beautiful brown cows!
strcat(s1,"s!");
printf("%s\n", s1);
return 0;
}
26
 Practice Problems
1. Write a function to search for an element in an array of integers that
returns 1 if the element is found, 0 otherwise. If found, it also returns the
index in the array where found
2. Write a function that returns the number of lowercase letters, uppercase
letters, and digit characters in a string
3. Define a structure POINT to store the coordinates (integer) of a point in 2-
d plane. Write a function that returns the two farthest (largest distance)
points in an array of POINT structures
4. Write a function that takes two arrays of integers A and B and returns the
size of the union set and the size of the intersection set of A and B
5. Write a function that returns the lengths of the largest palindromes formed
by any substring (sequence of consecutive characters) of the string. It
should also return the index in the string from which the palindrome starts.

For all of the above, add suitable main() functions to call the functions. Also,
decide on what parameters you will need; for better practice, for all problems
other than problems 1, assume that the return type of the function is void.
27