- 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 set of variables
that collectively represent (more) complete information
on the same entity
- Example:
-
A student has a name, address, phone number and major
"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; ... };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 or
class
can also be defined in
C++ (NOT C) as follows:
class ClassName { [private:|public:|protected:] type1 element1; type2 element2; type3 element3; ... };class myClass { public: int i; float f; };After defining the class, you can define variables of this class as follows:
ClassName variableName; NOTE: no keyword "class" !!!
A class is a complete type that behave exactly like built-in data types
A class also provides secure data access to special "privileged" functions (called member functions of a class)
NOTE: in the mean time, ALWAYS use public: - it will be explained later...
IMPORTANT IMPORTANT IMPORTANT IMPORTANT IMPORTANT
- The equivalence of a structure variable of C/C++ in Java
is a class/object variable
- There is a huge difference between how C/C++ and Java create storage
for such variables
How C++ define class/object variables: ClassName variableName; Example: ListElem x;
How Java define class/object variables: ClassName variableName; variableName = new ClassName(); Example: ListElem x; x = new ListElem();
C++ allows the programmer to create storage for the object variable in place.
Java always allocate (reserve) space for an object variable using the new operator which returns the location of the variable. The access to the object variable in Java is always indirect
- A structure typed variable is declared just like
a built-in type variable, with the keyword
extern:
extern struct StructureName variableName;
- A class typed variable is also declared
with the keyword
extern:
extern ClassName variableName; NOTE: no keyword "class" !!!
- After structure or class
variables are defined (or declared), you can use the
variables as follows:
x.i
The component variable "i" 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 in "x"
- 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; }
- Here is a program that contains (almost) every use of
a struct variable:
click here
- Here is a program that contains (almost) every use of
a class variable:
click here
- The de-reference operator * is
often used in C/C++ in
accessing structured
variables
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 will be discussed as part of the course description; and it is very useful in storing SPARSE matrices
- Example of Reference variables pointing
to structured variables
Class variable definition: class myClass { public: int i; float f; }; myClass x; // x is a // class variable // x has an int and // a float myclass *p; // p is a // reference variable // p holds an // address valueUsing class reference variables p = &x; // p points to x (*p).i // equivalent to x.i (*p).f // equivalent to x.f p->i // equivalent to (*p).i p->f // equivalent to (*p).f
- p = &x; makes p points to
the class variable x.
From now on, the expression *p is equivalent to x
- Therefore, to access x.i, we can now use:
(*p).i ---
the brackets () over *p is necessary due
operator associativity reasons (. and * are
right-to-left associative).
- Because accessing a component in a class/structure variable through a pointer is use very often (e.g.: (*p).i), C/C++ has provided a short hand operator: -> (it looks like a pointer too :-))
- p = &x; makes p points to
the class variable x.
- Example Program:
(Demo the -> operator) ---
click here