Short-hand operators
- C has
many
short-hand operators
- Short-hand operators
shortens
an expression written
using "non-short-hand" operators
Example:
Expression Expression with a short-hand operator
========== ========================================
i = i + 1; i++; (combines = and + into 1 operator)
i = i * 7; i *= 7; (combines = and * into 1 operator)
|
- In fact:
- Program languages
created by
European
Computer Scientists
(e.g.:
Algol, Pascal, Modula)
do not
use
any
short-hand operators....
|
|
The pointer-member-access operator
->
Previous, we have
used
(*p).fieldName
with
reference variables to
access
member variables in a
struct:
#include <stdio.h>
struct BankAccount
{
int ID;
float balance;
};
int main( int argc, char *argv[] )
{
struct BankAccount john, mary, *p ;
john.balance = 500;
p = &john; // Now *p ≡ john
(*p).balance = (*p).balance + 2000;
mary.balance = 500;
p = &mary; // Now *p ≡ mary
(*p).balance = (*p).balance + 9000;
printf("j: %f m:%f\n\n", john.balance, mary.balance);
}
|
The pointer-member-access operator
->
The
(binary) operator
->
is a
short hand operator for this
combination of operations:
(* ).
#include <stdio.h> // Operator -> is defined as: p->x ≡ (*p).x
struct BankAccount
{
int ID;
float balance;
};
int main( int argc, char *argv[] )
{
struct BankAccount john, mary, *p ;
john.balance = 500;
p = &john; // Now *p ≡ john
(*p).balance = (*p).balance + 2000;
mary.balance = 500;
p = &mary; // Now *p ≡ mary
(*p).balance = (*p).balance + 9000;
printf("j: %f m:%f\n\n", john.balance, mary.balance);
}
|
The pointer-member-access operator
->
We can
re-write this
program using the
->
operator as follows:
#include <stdio.h> // Program re-written using ->
struct BankAccount
{
int ID;
float balance;
};
int main( int argc, char *argv[] )
{
struct BankAccount john, mary, *p ;
john.balance = 500;
p = &john; // Now *p ≡ john
p->balance = p->balance + 2000;
mary.balance = 500;
p = &mary; // Now *p ≡ mary
p->balance = p->balance + 9000;
printf("j: %f m:%f\n\n", john.balance, mary.balance);
}
|
Notice the
graphical similarity
- The operator
->
kinda
depicts the
fact that
a
reference variable
points to
another variable:
In the above figure:
|
❮
❯