- Special feature of C:
- C is a special programming language that provides a data type that few programming languages dare to provide
- Reference (or
pointer) data type:
- Reference =
an address in memory
- A reference is also known as
a pointer
Example:
The address
The address 4 points to memory location 4 in the memory
- A reference is also known as
a pointer
- Reference data type = a data type that consists of all address of the memory
- Reference =
an address in memory
- Reference variable:
- Reference variable =
a variable that can contain
a reference (= address)
- Typically:
- Reference variable = a variable that contains the address of another variable
- Reference variable =
a variable that can contain
a reference (= address)
- Syntax:
dataType *varName ;Meaning:
- The variable varName can contain the address of a variable of the data type dataType
- Example:
int *p ; // p can contain the address of an int typed variable float *q ; // q can contain the address of a float typed variable(I will explain the notation in a later webpage)
- Recall that:
- The reference operator
&
"computes" (returns) the
address of a variable:
int a; &a returns: the address of the variable aNote:
- Because the variable a is of the type int, the address &a is an address of an int typed variable !!!
- We have just learned how to
define a variable where you can
store an
address
of an
int typed variable:
int *p ;
- The reference operator
&
"computes" (returns) the
address of a variable:
- So now should understand how you can
assign a value to a
reference variables:
int a; // an int typed variable // So: a can store an integer value int *p; // p can hold an address of an int typed variable // So: p can store an address of an integer variable p = &a; // Store the address of the int type variable a in pWhat happens inside the computer:
- First, the variable definitions
will allocated (reserve) space
in the memory:
- The assignment statement
p = &a; will
store the
address of the variable
a (5000) into
the (reference) variable
a:
- Result:
the variable p
points to the variable
a:
- First, the variable definitions
will allocated (reserve) space
in the memory:
- Recall that:
- The de-reference operator *
"computes" (returns) the
value stored at a given address:
(int *) 5000 means: 5000 is the address of an int typed variable * (int *) 5000 returns: the int value stored at address 5000
- The de-reference operator *
"computes" (returns) the
value stored at a given address:
- Applying
the de-reference oprator *
on a reference variable:
- If p is
a reference variable
defined as:
int *p ; // p contains an address of an int
Then the expression:
*p // You must read this as: // The operator * applied to the variable pwill return:
- The value stored at the
address given by the
variable p
- Also, the type of the data is int because variable p points to a int typed variable
- The value stored at the
address given by the
variable p
- If p is
a reference variable
defined as:
- Illustrated:
- Example C program:
int main(int argc, char *argv[]) { int i1 = 4, i2 = 88; int *p; printf("Address of i1 = %u\n", &i1 ); // %u = unsigned integer printf("Address of i2 = %u\n\n", &i2 ); p = &i1; // p points to variable i1 printf("Value of p = %u\n", p ); printf("Value of *p = %d\n\n", *p ); p = &i2; // p points to variable i1 printf("Value of p = %u\n", p ); printf("Value of *p = %d\n\n", *p ); }Output:
Address of i1 = 4290768712 Address of i2 = 4290768708 Value of p = 4290768712 Value of *p = 4 Value of p = 4290768708 Value of *p = 88
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link(s) and
save in a scratch directory
- To compile: gcc ref-var1.c
- To run: ./a.out
- Reminder of
an important fact:
- When a variable
appears at the
right hand side (LHS)
of an assignment operator
(e.g.: ... = ... a ...),
it means:
- Retrieve the value
(from the memory cells that
holds that value)
Graphically:
- Retrieve the value
(from the memory cells that
holds that value)
- When a variable
appears at the
left hand side (LHS)
of an assignment operator, it means:
- Replace the value
(of the memory cells that
holds that value)
Graphically:
- Replace the value
(of the memory cells that
holds that value)
- When a variable
appears at the
right hand side (LHS)
of an assignment operator
(e.g.: ... = ... a ...),
it means:
- Analogously, we can use the
expression
*p in the
right hand side
(which we saw before) and on the
left hand side
of
the assignment operator:
- When the expression *p
appears at the
right hand side (LHS)
of an assignment operator
(e.g.: ... = ... *p ...),
it means:
- Retrieve the value
(from the memory cells that
pointed to by the
reference variable p)
Graphically:
- Retrieve the value
(from the memory cells that
pointed to by the
reference variable p)
- When a variable
appears at the
left hand side (LHS)
of an assignment operator, it means:
- Replace the value
(of the memory cells that
holds that value)
Graphically:
- Replace the value
(of the memory cells that
holds that value)
- When the expression *p
appears at the
right hand side (LHS)
of an assignment operator
(e.g.: ... = ... *p ...),
it means:
- Example:
int main(int argc, char *argv[]) { int i1 = 4, i2 = 88; int *p; printf("Value of i1 = %d\n", i1 ); p = &i1; // p points to variable i1 *p = 1234; // Store 1234 in i1 !!! printf("Value of i1 = %d\n", i1 ); printf("Value of i2 = %d\n", i2 ); p = &i2; // p points to variable i2 *p = 9999; // Store 9999 in i2 !!! printf("Value of i2 = %d\n", i2 ); }Output:
Value of i1 = 4 Value of i1 = 1234 (i1 is changed !!!) Value of i2 = 88 Value of i2 = 9999 (i2 is changed !!!)
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link(s) and
save in a scratch directory
- To compile: gcc ref-var2.c
- To run: ./a.out
- Analogy:
- A reference variable contains an address --- just like address registers (e.g., A0) in M68000
- Suppose
the reference variable
p is
"equavalent" to
the address register A0.
Then:
C expression Similar to M68000 --------------------------------------------------- p A0 *p (A0) Examples: p = &var; move.l #var, A0 *p = 1234; move.l #1234, (A0)
- The operator &:
- &var =
the address of the
variable var
- The value of &var is
also known as
a reference
or a pointer
to the
variable var
(because it "points like an index finger" to the variable var)
- The value of &var is
also known as
a reference
or a pointer
to the
variable var
- &var =
the address of the
variable var
- The operator *
- The operator * can
only be
used on a reference variable
- A reference variable contains the address of a variable var (= &var)
- Suppose
a reference variable
p
is currently pointing to
some variable.
datatype *p; // p is pointing // to some variable of type datatype Then: p = the address of the variable (of type datatype) *p = the variable (of type datatype) that p is pointing to
- The operator * can
only be
used on a reference variable