Each property of the object is represented by one value (stored in a variable)

These variables collectively represent complete information on the entity

Conceptually: "Student = (name, address, phone_number, major)" Student John, Mary; // Define 2 students John.address // John's address Mary.address // John's address

This is the same concept of object in Java

struct StructureName { type1 element1; type2 element2; type3 element3; ... };

Example:

struct myStruct { int i; float f; };

struct myStruct x, A[3];

The struct construct is a remmant of C that is still supported by C++ (C++ is a superset of C) The use of struct in C++ - however - has been superseded by the class I only mention struct for completeness sake. We will only use class for the rest of the discussion

class ClassName { [private:] [public:] [protected:] type1 var1; type2 var2; type3 var3; ... };

Example:

class myClass { public: int a; // public float b; // public private: int a; // private float b; // private protected: int a; // protected float b; // protected } ; // ***** NOTE: ends in a semi-colon !!!

C++ takes a "toggle"-approach to denote access specifiers The keywords public, private and protected toggles the start of a section of variables In contrast, Java uses an explicit enumeration approach. Every variable must be explicitly denoted as public, private or protected The Java approach is more verbose but will also result in less confusion (less error-prone)

ClassName variableName;

Example:

myClass x; // x is a myClass variable myClass a[10]; // array of 10 variables myClass *p; // p contains an address of myClass variable

The object itself (representation of the real entity) is created using the new operator

class myClass { int x; float y; }; myClass a; myClass b[4];

will create the following:

A C++ class variable contains all the member variables in the class In other words: the object is stored in the C++ class variable - not just an address as in Java

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

Functions and Operations defined inside a class are called member functions/operations

There are 3 levels of security:

• public (open to all)
• protected
• private (open only to functions defined in the class)

For now, I will ALWAYS use public: - the difference will be explained later...

struct myStruct x; // Definition of the struct variable x extern struct myStruct x; // Declaration of the struct variable x

myClass x; // Definition of the class variable x extern myClass x; // Declaration of the class variable x

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"

• pass-by-value or

• pass-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; }

void Print2(myClass h) { cout << "Structure values = (" << h.i << ", " << h.f << ")\n"; h.i = h.i + 1000; h.f = h.f + 1000; }

void Print1(struct myStruct & h) { cout << "Structure values = (" << h.i << ", " << h.f << ")\n"; h.i = h.i + 1000; h.f = h.f + 1000; }

void Print2(myClass & h) { cout << "Structure values = (" << h.i << ", " << h.f << ")\n"; h.i = h.i + 1000; h.f = h.f + 1000; }

• Prog file: click here

• Prog file: click here

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

(* reference_var).MEMBER

is a commonly used expression, C/C++ has a short hand for this expression:

reference_var->MEMBER

p->i = 4; // equivalent to (*p).i p->f = 3.14; // equivalent to (*p).f

• Prog file: click here