- Built-in types
provided by C/C++ allow the programmer to define
variables to store very simple values
- Most computer applications (even numerical programs)
will use an array of different kinds of values.
- Although the programmer can define multiple variables to
store the various values, managing
the different values stored in a large number of variables
can be more complicated that it ought to be....
- Every modern programming languages allow the programmer to define
structured variables
that enable the programmer to all the different kinds of value
in one place
- Some modern programming languages
(e.g., Java)
will even allow the programmer to define
functions
that will ONLY operate on
the prescribed type of variables
(object oriented programming languages)
- A few programming languages (e.g., C++, Algol68) go all the way and allow the programmer to define operators that will ONLY operate on the prescribed type of variables
- Structured variables is
collection of variables
These variables collectively represent (more) complete information on the same entity and are group together for convenience
- Example:
A student has a name, address, phone number and major
Conceptually: "Student = (name, address, phone_number, major)"
Student John, Mary; // Define 2 students John.address // John's address Mary.address // John's address
- A structure or
structured types are defined in
C (and C++) as follows:
struct StructureName { type1 element1; type2 element2; type3 element3; ... };Example: struct myStruct { int i; float f; };
- After defining the structure, you can define
variables of this
structure as follows:
struct StructureName variableName;
struct myStruct x, A[3];
- A
more powerful structure construct
available in C++ is:
class
- Syntax to
define
a class structure
in C++ (NOT available in C):
class ClassName { [private:|public:|protected:] type1 element1; type2 element2; type3 element3; ... };Example: class myClass { public: int i; float f; };
After defining the class structure, you can define variables of this class as follows:
ClassName variableName; NOTE: no keyword "class" !!!
Example: myClass x, A[3];
A class is a complete type that behave exactly like built-in data types:
- You can define functions that operation exclusively on variable of a class
- You can define operations (e.g., +, -, etc) that operation exclusively on variable of a class
- Definition:
Functions and Operations defined inside a class are called member functions/operations
- A class also provides a more
secure data access
There are 3 levels of security:
- public (open to all)
- protected
- private (open only to functions defined in the class)
- Member functions of a class
has
special privileges
- NOTE:
For now, I will ALWAYS use public: - the difference will be explained later...
- A structure typed variable is
declared
just like
a built-in type variable, with the keyword
extern
- Example: struct variable
struct myStruct x; // Definition of the struct variable x
extern struct myStruct x; // Declaration of the struct variable x - Example: class variable
myClass x; // Definition of the class variable x
extern myClass x; // Declaration of the class variable x
- After structure or class
variables are defined (or declared), you can use the
variables as follows:
struct myStruct class myClass { { public: int i, j, k; int i, j, k; float x, y, z; int x, y, z; }; }; struct myStruct x; myClass x;x.i
The component (integer) variable "i" in "x" x.x
The component (float) variable "x" in "x" &(x.i)
Address of the component variable "i" in "x" x
The entire object "x" (all components) &x
The address of "x". It is also equal to the address of the first component (variable i) in "x"
- Structured variables
(struct and class)
can be passed to functions as:
- pass-by-value or
- pass-by-reference
- pass-by-value or
- I.e.: just like built-in types
- How to pass
struct variable
by VALUE:
void Print1(struct myStruct h) { cout << "Structure values = (" << h.i << ", " << h.f << ")\n"; h.i = h.i + 1000; h.f = h.f + 1000; }
- How to pass
class variable
by VALUE:
void Print2(myClass h) { cout << "Structure values = (" << h.i << ", " << h.f << ")\n"; h.i = h.i + 1000; h.f = h.f + 1000; }
- How to pass
struct variable
by REFERENCE:
void Print1(struct myStruct & h) { cout << "Structure values = (" << h.i << ", " << h.f << ")\n"; h.i = h.i + 1000; h.f = h.f + 1000; }
- How to pass
class variable
by REFERENCE:
void Print2(myClass & h) { cout << "Structure values = (" << h.i << ", " << h.f << ")\n"; h.i = h.i + 1000; h.f = h.f + 1000; }
- Example Program:
(Pass
struct
variable
by value
and
by reference )
- Prog file: click here
- Example Program:
(Pass
class
variable
by value
and
by reference )
- Prog file: click here
- The
de-reference operator *
is
often used in C/C++ in
accessing structured
variables
- Example:
Class variable definition: class myClass { public: int i; float f; }; myClass x; // x is a myClass variable myclass *p; // p is a reference variable // (reference a myClass variable p = &x; // Now p points to x (*p).i = 4; // equivalent to x.i (*p).f = 3.14; // equivalent to x.f
- Because the combination:
(* reference_var).MEMBER
is a commonly used expression, C/C++ has a short hand for this expression:
reference_var->MEMBER
- Example:
p->i = 4; // equivalent to (*p).i p->f = 3.14; // equivalent to (*p).f
- Example Program:
(Demo the use of -> )
- Prog file: click here
- The prime example where the de-reference operator *
is used with structured variables is maintaining (= accessing,
creating and destroying)
a
linked list
structure
- The
linked list
structure is
one of the
data structure that is used to
represent sparce matrices
- The linked list structure will be discussed next...