9 CPS393 DataStructuresC

C/CPS 393
Introduction to UNIX, C and C++

Prof. Alex Ufkes
Topic 9: Data structures in C

Notice!
Obligatory copyright notice in the age of digital

delivery and online classrooms:
The copyright to this original work is held by Alex Ufkes. Students

registered in course C/CPS 393 can use this material for the purposes
of this course but no other use is permitted, and there can be no sale
or transfer or use of the work for any other purpose without explicit
permission of Alex Ufkes.
© Alex Ufkes, 2022 2

Course Administration
Three weeks to go!

Final exam covers C, takes
place during exam period.

Today
Structured Data in C
2D arrays (static VS dynamic)
Arrays of strings
Structs, Linked Lists

2D Arrays
Recall: 1D Static Arrays
#include <stdio.h>
int main()
{
int nums[100]; An array of 100 integers
return 0;
}
2D Static Arrays
We simply add another set of square brackets [ ]
#include <stdio.h>
int main()
{
int nums[10][10]; A 2D array, 10 by 10
return 0;
}
ND Static Arrays
As many dimensions as you want:
#include <stdio.h>
int main()
{
int nums[5][5][5][5][5];
return 0;
}
#include <stdio.h>
int main()
{
int nums[3][2] = {{1, 2}, {3, 4}, {5, 6}};
return 0;
} Row 1 Row 2 Row 3
3 rows 2 columns
1 2 3 4 5 6 Memory
Row 1 Row 2 Row 3

2D Memory
Memory is NOT 2D!
Addressing is one dimensional!

Static 2D arrays are still allocated as contiguous 1D chunks.
1 2 3 4 5 6 Memory
Row 1 Row 2 Row 3

#include <stdio.h>
int main()
{
int nums[3][2] = {{1, 2}, {3, 4}, {5, 6}};
return 0;
}
The name of a static, 2D array is STILL
just a pointer to the first element!
1 2 3 4 5 6 Memory
nums == &nums[0][0]
#include <stdio.h>
int main()
{
int matrix[2][2]; 2 rows, 2 columns
Row index Column index
matrix[0][0] = 17; /* row 0, col 0 */
matrix[0][1] = -3; /* row 0, col 1 */
matrix[1][0] = 0; /* row 1, col 0 */
matrix[1][1] = 57; /* row 1, col 1 */
return 0;
}
#include <stdio.h>
int main()
{
int matrix[2][2];
scanf( , &matrix[0][0]);
Just like 1D arrays!
return 0;
}
#include <stdio.h>
int main()
{
int matrix[][] = {{1,2,3},{4,5,6},{7,8,9}};
int row, col;
for (row = 0; row < 3; row++) {
for (col = 0; col < 3; col++) {
printf( , matrix[row][col]);
}
printf( \ );
}
return 0;
}
2D Static Arrays as Arguments
Create a function for matrix addition. It will take in

three arguments. The two matrices to be added, and a
third matrix to store the result.
#define M 3 /* number of matrix rows */
#define N 3 /* number of matrix columns */
void addMatrix(int a[M][N], int b[M][N], int c[M][N])
{
int row, col;
for (row = 0; row < M; row++) {
for (col = 0; col < N; col++) {
c[row][col] = a[row][col] + b[row][col];
}
}
}
{ /* addMatrix code from previous slide here */ }
int main()
{
int mat1[M][N] = {{1,2,2},{2,-3,6},{1,0,-3}};
int mat2[M][N] = {{1,1,1},{1,6,2},{1,-1,-1}};
int result[M][N];
addMatrix(mat1, mat2, result);
return 0;
}
{
/* addMatrix code here */
}
Notice: We are specifying the array size!
At minimum, we must specify the size of

each row (number of columns)
void addMatrix(int a[][N], int b[][N], int c[][N])
{
/* addMatrix code here */
}
Notice: We are specifying the array size!
At minimum, we must specify the size of

each row (number of columns). Why?
#include <stdio.h>
int main()
{
int nums[3][2] = {{1, 2}, {3, 4}, {5, 6}};
printf( , nums[1][1]);
return 0;
}
If nums is just a pointer to the first element,
how do we know where the 2nd row begins?
1 2 3 4 5 6 Memory
#include <stdio.h>
int main()
{
int nums[3][2] = {{1, 2}, {3, 4}, {5, 6}};
return 0;
}
The compiler knows that the 2nd row starts at index 2

because it knows how many columns there are.
1 2 3 4 5 6 Memory
#include <stdio.h>
int main()
{
int nums[3][2] = {{1, 2}, {3, 4}, {5, 6}};
return 0;
}
one row ends and another begins. 2D indexing would not be possible.
1 2 3 4 5 6 Memory
void addMatrix(int a[][N], int b[][N], int c[][N])
{
int row, col;
for (row = 0; row < M; row++)
for (col = 0; col < N; col++)
c[row][col] = a[row][col] + b[row][col];
}
Therefore, this is sufficient, but omitting the

number of rows and columns entirely is not.
2D Array Allocation: CS
Recall: A dynamic 1D array is a pointer to a chunk of

reserved memory (calloc)
arr
int *arr = (int*) calloc(4, sizeof(int));

Treat a 2D array as an array of 1D arrays

Treat a 2D array as an array of 1D arrays
How can we
use calloc to
achieve this?
int i, nrows = 3, ncols = 4;
int **nums; /* Double pointer! A pointer to an array of pointers */
/* Allocate the array of pointers */
nums = (int**) calloc(nrows, sizeof(int*));
/* Allocate the arrays of integers, one for each row */

for (i = 0; i < nrows; i++)
nums[i] = (int*) calloc(ncols, sizeof(int));
/* At this point, nums can be treated like ANY OTHER statically declared
2D array. Rules for accessing and modifying elements are THE SAME. */
/* Free each row, then free the array of pointers */

free(nums[i]);
free(nums);
int i, nrows = 3, ncols = 4;
int **nums;
nums = (int**) calloc(nrows, sizeof(int*));
nums[i] = (int*) calloc(ncols, sizeof(int));
free(nums[i]);
free(nums);
Accessing elements is the same!
nums[2][2]
2D Array Allocation: ENG
Simulate a 2D array using a 1D array:
Stack each row one after another

#include <stdio.h>
int main()
{
int nums[3][2] = {{1, 2}, {3, 4}, {5, 6}};
return 0;
}
1 2 3 4 5 6 Memory
This is what happens in memory when declaring a static 2D array.

However, there is one key
#include <stdio.h>
int main()
{
int nums[3][2] = {{1, 2}, {3, 4}, {5, 6}};
return 0;
}
1 2 3 4 5 6 Memory
We can no longer access elements using two

indices (nums[0][0]
int nrows = 3, ncols = 4;
int *nums; /* Regular pointer! We are going to create a 1D array */
/* Allocate the 1D array of integers */

nums = (int*) calloc(nrows*ncols, sizeof(int));
TOTAL number of array elements
/* Do stuff with the array. Unlike the computer science method, accessing
/* Free the array */

free(nums);
2D Array Allocation: ENG
Accessing array elements when using the engineering method:

int *nums, nrows = 3, ncols = 4;
nums = (int*) calloc(nrows*ncols, sizeof(int));
We use a general formula to access row X, column Y:
nums[X*(num_cols) + Y];
Linear index of 2D array
2 columns
3 rows
first row second row third row
To access element [0][0]?

nums[0*(2) + 0];
nums[0];
2 columns
3 rows

nums[1*(2) + 0];
nums[2];
2 columns
3 rows

nums[2*(2) + 1];
nums[5];
Zuck VS Iron Man
Computer science method:

Harder to set up, easier to use once set up.
Cost: follow two pointers, 1+nrow calloc calls
Engineering method:
Easier to set up, harder to use once set up.
Cost: Calculate linear index. One multiplication,
one addition. Single calloc call.
Zuck AND Iron Man
Best of both worlds: Cache locality AND 2D indexing!
int R = 3, C = 3;
ENG int *arr = (int*) calloc(R*C, sizeof(int));
CS int **mat = (int**) calloc(R, sizeof(int*));
mat[0] = arr;
for (int i = 1; i < R; i++)
mat[i] = mat[i-1] + C;
Two 1D arrays:
First to hold all elements in the ENG style.
Second to enable 2D indexing in the CS style
Each int* in mat points to the start of a row in arr
Fill and print mat elements using 2D indexing!
Print addresses stored in mat.

Adjacent addresses are separated
by 12: C*sizeof(int)
integer
→ 4 bytes
Printing this pointer as %d gives a compile warning.
© Alex Ufkes, 2022 int is 4 bytes, int* is 8 bytes. We print the lower 4 bytes. 47
int R = 3, C = 3;
int *arr = (int*) calloc(R*C, sizeof(int));
int **mat = (int**) calloc(R, sizeof(int*));
mat[0] = arr; Address
of the
first element
first in the position .
for (int i = 1; i < R; i++)

mat[i] = mat[i-1] + C;
Memory
arr mat[0] mat[1] mat[2]

mat[0][0] mat[1][0]
mat[2][0]
mat[0][1] mat[1][1]
mat[2][1]
mat[0][2] mat[1][2]
mat[2][2]
Memory
arr mat[0] mat[1] mat[2]

Arrays of
© Alex Ufkes, 2020, 2021 50

Array of Strings
#include <stdio.h>
int main()
{
char months[12][10];
return 0;
}
Maximum length
Number of strings
of each string
Array of Strings
Initialize using literals:
char months[12][10] =
{ , , ,
, , ,
, , ,
, , };
Value of months[7][3]?
The memory is ours, but we
Value of months[9]?
Address of the first character
of October - &months[9][0]
printf( , months[9]);
Console
January
February
March char months[12][10] =
{ , , ,
April , , ,
May , , ,
June , , };
July
August
September for (i = 0; i < 12; i++)
October printf( \ , months[i]);
November
December
Structs
A collection of variables, types can vary
struct ball
{
char style[10];
double radius;
double weight;
};
#include <stdio.h>
#include <math.h>
struct ball
{ Structure definitions:
char style[10]; Typically placed between
double radius; preprocessor directives
double weight; and function prototypes.
};
int abc(int x);

double xyz();
int main()
{
return 0;
}
struct ball
{
char style[10];
double radius;
double weight;
};
int main()
{
struct ball b1, b2, b3, b[50]; Or as an array
Declare individually
}
struct ball
{
char style[10];
double radius;
double weight;
};
Use the dot operator to access a
int main() individual variables.
{
struct ball b1;
b1.radius = 4.6;
b1.weight = 22.1;
strcpy(b1.style, );
} ↓
destination element
the first
of
address
struct ball
{
char style[10];
double radius;
double weight;
};
int main()
{
struct ball b[50];
int i;
for (i = 0; i < 50; i++) {
Initialize radius
b[i].radius = 0.0;
b[i].weight = 0.0; and weight to 0.0
}
}
struct1 = struct2;
Assigns one struct to another
Assuming the same structure type
All member variable values are copied!

struct BirthdayInfo int main()
{ {
int year;
struct BirthdayInfo x, y;
int month;
int day; x.year = 1975;
}; x.month = 8;
x.day = 15;
y.year = 2008;
y.month = 12;
y.day = 2;
y.year = x.year;
y.month = x.month; y = x;
y.day = x.day; printf( \ , y.year,
equivalent y.month, y.day);
}
struct BirthdayInfo int main()
{ {
int year;
struct BirthdayInfo x, y;
int month;
int day; x.year = 1975;
}; x.month = 8;
x.day = 15;
y.year = 2008;
stdout: y.month = 12;
y.day = 2;
1975/8/15
y = x;
printf( \ , y.year,
y.month, y.day);
}
typedef
Create an Alias
#include <stdio.h>
typedef int integer;
alias for type int
int main()
{
integer x, y, z;
x = 1; integer can now be used as a type!
y = 2; same as int, except for the
z = x + y; name.
}
Common for Structures
typedef struct ball Now, instead of declaring:

{ struct ball b1, b2, b3;
char style[10];
double radius; We can simply declare:
double weight;
} ball; ball b1, b2, b3;
Common for Structures
Alias can be different from struct name:
typedef struct ball Declaration:

{ basketball b1, b2, b3;
char style[10];
double radius; Can still declare:
double weight; struct ball a, b, c;
} basketball;
typedef struct ball
{
char style[10];
double radius;
double weight;
} basketball;
int main()
{
basketball b1 = { , 3.4, 6.8};
return 0;
}
typedef struct ball
{
char style[10];
double radius;
double weight;
} basketball;
Can read values directly into a

int main() member variables.
{
basketball b1, b2;
printf( );
scanf( lf , &b1.radius);
return 0;
}
Structures & Functions
Structures passed as input to a function are COPIED into

the corresponding function parameter. All member
variables are copied as well.
This is DIFFERENT from arrays, which are NOT copied. Only the
base address of the array is copied, not the elements.
typedef struct ball
{ struct ball is defined and
char style[10];
given an alias before the
double radius;
double weight;
function printElements
} basketball;
void printElements(basketball b)
{
printf( \ , b.style);
printf( lf\ , b.radius);
printf( lf\ , b.weight);
}
typedef struct ball void printElements(basketball b)
{ {
char style[10]; printf( \ , b.style);
double radius; printf( lf\ , b.radius);
double weight; printf( lf\ , b.weight);
} basketball; }
b1 and its member
int main() values are copied into b
{
basketball b1 = { , 11.4, 212.8};
printElements(b1);
return 0;
}
Write a user-defined function that does the following:
Takes in two basketball structs as arguments and
compares the radius and the weight. Returns 1 if they
are the same, and 0 if they are different.
Two basketball structs as input arguments
int comp(basketball b1, basketball b2)

{
int isEqual;
isEqual = (b1.radius == b2.radius) &&

(b1.weight == b2.weight);
return isEqual; What is the output of a

} logical expression?
int comp(basketball b1, basketball b2)
{
return (b1.radius == b2.radius) && (b1.weight == b2.weight);
}
int main()
{
basketball b1 = { , 11.4, 212.8};
basketball b2 = { , 11.4, 212.8};
if (comp(b1, b2))
printf( \ );
else
printf( \ );
return 0;
}
Write a user-defined function that does the following:
Takes in zero arguments, and returns a basketball struct.
The function will ask the user to enter values for each of
basketball
basketball readElements(void)
{
basketball b;
printf( );
scanf( , b.style);
printf( );
scanf( lf , &b.radius);
printf( );
scanf( lf , &b.weight);
return b;
}
basketball readElements(void) void printElements(basketball b)
{ {
basketball b; printf( \ , b.style);
printf( ); printf( lf\ , b.radius);
scanf( , b.style); printf( lf\ , b.weight);
printf( ); }
scanf( lf , &b.radius);
printf( );
scanf( lf , &b.weight); It is possible to return an
return b;
}
entire struct. Unlike arrays,
ALL values are copied.
int main()
{
basketball b1 = readElements();
printElements(b1);
return 0;
}
yapacagim
.
ilene
hell Zeynep
why
the dur
dagan
.
Neyapmam
Mike
feeling
m'
man
i am yasmam mi
gonna
outsider with AM Yamamura ,

sonra neaten
yanmadm
an
around me
i rtaiti yor
'
oilman beni
.
people tephra no
-
these
void swap(struct foo input)
{
int tmp = input.a;
struct foo { input.a = input.b;
input.b = tmp;
int a, b;
}
};
int main()
{
struct foo f1 = {1, 2};
printf( , f1.a, f1.b);
swap(f1);
return 0;
}
void swap(struct foo input)
{
int tmp = input.a; What is the output?
input.a = input.b; Before swap: 1 2
input.b = tmp;
} After swap: 1 2
F1 is copied
int main() into input.
{
struct foo f1 = {1, 2};
swap(f1);
return 0;
}
typedef struct foo {
int a, b;
} foo;
void swap(foo input) void swap(foo *input)

{ {
int tmp = input.a; int tmp = input->a;
input.a = input.b; input->a = input->b;
input.b = tmp; input->b = tmp;
} }
If input is a pointer to a struct, we use the

arrow operator (->) instead of the dot operator.
void swap(foo *input)
{
int tmp = input->a; What is the output?
input->a = input->b;
input->b = tmp; Before swap: 1 2
} After swap: 2 1
int main()
{
foo f1 = {1, 2};
printf( \ , f1.a, f1.b);
swap(&f1);
return 0;
}
We can also dereference!
void printElements(basketball *b)
{
printf( \ , b->style);
printf( lf\ , b->radius);
printf( lf\ , b->weight);
}
Is the same as:
void printElements(basketball *b)
{
printf( \ , (*b).style); Must use parentheses
printf( lf\ , (*b).radius); (*b) otherwise the dot
printf( lf\ , (*b).weight); operator is applied first
}
An ordered set of data elements, each
containing a link to its successor.
(and in some cases, its predecessor)
These data elements can be structs in C
NULL pointer, there

is no 4th element
Address of 3rd data element

typedef struct monkey
{
char name[10];
double weight;
struct monkey *next;
} monkey;
Pointer to struct monkey as a member

variable of struct monkey
/* The start variable pointer to
a monkey node */
monkey *start;
/* The nodes 3 monkey structs */

monkey m1, m2, m3;
m1 m2 m3
monkey *start;
monkey m1, m2, m3;
strcpy(m1.name, );
strcpy(m2.name, );
strcpy(m3.name, );
m1 m2 m3
monkey *start;
monkey m1, m2, m3;
m1.weight = 300;
m2.weight = 150;
m3.weight = 120;
Is the linked list complete?
m1 m2 m3
300 150 120
monkey *start;
monkey m1, m2, m3;
strcpy(m1.name, );
strcpy(m2.name, );
strcpy(m3.name, );
m1.weight = 300;
m2.weight = 150; start = &m1;
m3.weight = 120;
m1.next = &m2;
m2.next = &m3;
m3.next = NULL;
m1 m2 m3
300 150 120
Linked List Traversal
Starting at the first node, visit every subsequent
node until the final node is reached.
Linked List Traversal
monkey *p;
int count = 0; /* count monkeys */
element
Madness equal to first
for (p = start; p != NULL; p = p->next)

{
instance of
pointer
not
is a ,
a
the struct .
count = count + 1;
printf( \ , count, p->name);
}
m1 m2 m3
300 150 120
monkey *p;
{
count = count + 1;
}
Console
Monkey 1 is Donkey.
m1 m2 m3
300 150 120
monkey *p;
{
count = count + 1;
}
Console
Monkey 1 is Donkey.
m1 m2 m3
300 150 120
monkey *p;
{
count = count + 1;
}
Console
Monkey 1 is Donkey.
Monkey 2 is Diddy.
m1 m2 m3
300 150 120
monkey *p;
{
count = count + 1;
}
Console
Monkey 1 is Donkey.
Monkey 2 is Diddy.
Monkey 3 is Dixie.
m1 m2 m3
300 150 120
monkey *p;
{
count = count + 1;
}
Console
Monkey 1 is Donkey.
p
Monkey 2 is Diddy.
done traversing! Monkey 3 is Dixie.
m1 m2 m3
300 150 120
Linked Lists & Functions
Pass a linked list into a function as an argument.
Implement traversal as a function and return the
number of nodes that were traversed.
Traverse function:
int traverse (monkey *first)

{
monkey *p;
int count = 0; /* count monkeys */ indigo
for (p = first; p != NULL; p = p->next)
{ me
count = count + 1;
}
return count;
}
Main function:
int main ()
{
strcpy(m1.name, );
monkey *start; strcpy(m2.name, );
monkey m1, m2, m3; strcpy(m3.name, );
m1.weight = 300;
int num; m2.weight = 150;
m3.weight = 120;
num = traverse(start); start = &m1;
m1.next = &m2;
printf( , num); m2.next = &m3;
m3.next = NULL;
return 0;
}
More Examples
typedef struct element {
int num;
struct element *next;
} element;
int main ()
{
element e1, e2, e3, e4, *current;
e1.num = 1; e2.num = 2; e3.num = 3; e4.num = 4;
e1.next = NULL; e2.next = &e3; e3.next = &e4; e4.next = &e1;
current = &e2;
while (current != NULL) {
printf( , current->num);
current = current->next;
}
return 0;
}
current = &e2;
current = &e2;
current = &e2;
current = &e2;
while (current != NULL) {
printf( , current->num);
}
Console
2 3 4 1
Dynamic
Linked list allocation
Recall dynamic array allocation for primitives (int, double, char, etc.)
int size;
char *array; /* 1. Pointer to character array */
printf( );
scanf( , &size);
/* 2. Allocate array dynamically using calloc */
array = (char*) calloc(size, sizeof(char));
/* 3. Use array normally */
free(array); /* 4. Free array */

Write code to do the following:
Dynamically allocate a linked list of monkey nodes. Prompt the user
for name and weight.
The code will create (dynamically!) at least one node. Prompt the user
after each node to see if they would like to add another. If yes, allocate
the new node and prompt for name and weight. If no, the program
ends.
monkey *first, *current;
int addAnother;
/* Create first node */

first = (monkey*) calloc(1, sizeof(monkey));
current = first;
Notice!
Our node has no identifier.
We access it using a pointer.
int addAnother;
current = first;
printf( );
scanf( , current->name);
printf( );
scanf( lf , &current->weight);
We now have one dynamically allocated node

with values for name and weight.
280
So far so good?
int addAnother;
current = first;
printf( );
printf( );
printf( );
scanf( , &addAnother);
If the user keeps entering 1, we

keep adding monkeys.
280 This calls for a loop!

printf( );
while (addAnother)
{
current->next = (monkey*) calloc(1, sizeof(monkey));
We created a new node, and

updated our current pointer.
first always points to the first node.
280
while (addAnother) {
printf( );
Fill node as usual
printf( );
280 450
printf( );
printf( );
printf( );
}
280 450
while (addAnother)
{
printf( );
printf( );
printf( );
}
280 450
while (addAnother)
{
printf( );
printf( );
printf( );
}
280 450
while (addAnother)
{
printf( );
printf( );
printf( );
}
280 450 Koba 310

/* Loop code in here */
}
current->next = NULL;
280 450 Koba 310

int addAnother;
current = first;
printf( );
printf( );
printf( );
while (addAnother)
{
printf( );
printf( );
scanf( lf , &current->weight); The complete code
printf(
); ^
mostly
}
int addAnother;
current = first;
int traverse (monkey *first)
printf( );
{
printf( ); monkey *p;
scanf( lf , &current->weight); int count = 0; /* count monkeys */
printf( ); for (p = first; p != NULL; p = p->next)
scanf( , &addAnother); {
while (addAnother) count = count + 1;
{ printf( \ , count, p->name);
}
printf( ); return count;
scanf( , current->name); }
printf( );
printf( );
}
printf( \ , traverse(first));
Summary
Structured Data in C
2D arrays (static VS dynamic)
Arrays of strings
Structs, Linked Lists


9 CPS393 DataStructuresC

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

9 CPS393 DataStructuresC

Uploaded by

Copyright:

Available Formats

C/CPS 393

Introduction to UNIX, C and C++

Topic 9: Data structures in C

Obligatory copyright notice in the age of digital

The copyright to this original work is held by Alex Ufkes. Students

© Alex Ufkes, 2022 2

Three weeks to go!

© Alex Ufkes, 2022 3

© Alex Ufkes, 2022 4

We simply add another set of square brackets [ ]

As many dimensions as you want:

Row 1 Row 2 Row 3

Memory is NOT 2D!

Addressing is one dimensional!

Row 1 Row 2 Row 3

Create a function for matrix addition. It will take in

Notice: We are specifying the array size!

At minimum, we must specify the size of

Notice: We are specifying the array size!

At minimum, we must specify the size of

The compiler knows that the 2nd row starts at index 2

Therefore, this is sufficient, but omitting the

Recall: A dynamic 1D array is a pointer to a chunk of

int *arr = (int*) calloc(4, sizeof(int));

Treat a 2D array as an array of 1D arrays

Treat a 2D array as an array of 1D arrays

/* Allocate the arrays of integers, one for each row */

/* Free each row, then free the array of pointers */

Simulate a 2D array using a 1D array:

Stack each row one after another

This is what happens in memory when declaring a static 2D array.

We can no longer access elements using two

/* Allocate the 1D array of integers */

/* Free the array */

Accessing array elements when using the engineering method:

We use a general formula to access row X, column Y:

To access element [0][0]?

To access element [1][0]?

To access element [2][1]?

Computer science method:

Best of both worlds: Cache locality AND 2D indexing!

Each int* in mat points to the start of a row in arr

Fill and print mat elements using 2D indexing!

Print addresses stored in mat.

for (int i = 1; i < R; i++)

arr mat[0] mat[1] mat[2]

arr mat[0] mat[1] mat[2]

© Alex Ufkes, 2020, 2021 50

Initialize using literals:

A collection of variables, types can vary

int abc(int x);

All member variable values are copied!

typedef struct ball Now, instead of declaring:

Alias can be different from struct name:

typedef struct ball Declaration:

Can read values directly into a

Structures passed as input to a function are COPIED into

int comp(basketball b1, basketball b2)

isEqual = (b1.radius == b2.radius) &&

return isEqual; What is the output of a

outsider with AM Yamamura ,

void swap(foo input) void swap(foo *input)

If input is a pointer to a struct, we use the

int arr = (int) calloc(4, sizeof(int));