Private Methods
At this time, we know that one of the responsibilities of a member method of an object is to carry assignments. Another job performed by methods is to communicate with the clients of an object. As you might have found out, some of the methods of an object are exclusively used to carry assignments. The external functions or other objects do not call such methods and do not communicate with them. If you create a class and know that a particular member method is not used to transfer data to the client methods, you can declare such a method as private, just like you would do with a member variable.
To declare a method as private, include it in the private section of the object. To implement it, follow the same rules we have learned about implementing the methods of an object. The biggest difference you must keep in mind (which will also be very important when we learn about inheritance) is that this function method is not available to the outside world. Here is an example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | class Employee { public: void IdentifyEmployee(); string FullName() const { return FirstName + " " + LastName; } void GetHourlySalary(); void CalcTotalHours(); void Display(); void CalcNetPay() { if( IsMarried() == false ) NetPay = GrossPay - (GrossPay * 30 / 100); else NetPay = GrossPay; } private: void CalcGrossPay(); bool inline IsMarried() const; string FirstName; string LastName; double TotalHours; double HourlySalary; double WeeklySalary; double GrossPay; double NetPay; }; |
Objects and Their Implementations
An object is made of the material that compose it and the actual structure of the object, which defines how the object is built and used. This means, a class is be made of two parts: its building block and its definition. These two parts of a class can be kept in different files that have access to each other.
Class’ Header File
The building block or foundation of an class is made of the class’ creation, listing all of its members. This foundation is created in a file called a header file, similar to the one we learned when studying functions. The name of the file follows the naming rules we have applied so far. The header file has an extension of .h.
You create an object?s header file the same we did when studying functions. To create the header file, you can just define the class as an object. If some of the members are defined in files outsde of the object, include their header file(s).
Here is what our ShoeBox header file would look like
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | #include <iostream> #include <string> using namespace std; class ShoeBox { public: double CalcVolume() const { return Length * Width * Height; } void Area(const double Side1, const double Side2, char SideName[32]); float CalcShoeSize() const { return Length - 0.35; } void Display(); private: double Length; double Width; double Height; string Color; }; |
Difference Between Static & Global Variable
Variables defined local to a function disappear at the end of the function scope. So when we call the function again, storage for variables is created andvalues are reinitialized. So if we want the value to be extent throughout the life of a program, we can define the local variable as “static.” Initialization is performed only at the first call and data is retained between func calls.
Had it been goal variable, it would have been available outside the scope of the function, but static variable is not available outside the scope of a function (helpful in localizing errors – as it can’t be changed outside the function
scope).
Static and global variable differ a lot in their behavior to life and scope. First, let me distinguish between life and scope. Life of an object determines whether the object is still in the memory (of the process) whereas scope of the object is whether can I know the variable by its name at this position. It is possible that object is live, but not visible (not in scope) but not that object is not alive but in scope (except for dynamically allocated objects where you refer object through pointers).
Static variables are local in scope to their module in which they are defined, but life is throughout the program. Say for a static variable inside a function cannot be called from outside the function (because it’s not in scope) but is alive and exists in memory. The next time this function is entered (within the same program) the same chunk of memory would be accessed now retaining the
variables old value and no new memory is allocated this time for this variable like other variables in the function (automatic variables). So basically the variable persists throughout the program. Similarly if a static variable is defined in a global space (say at beginning of file) then this variable will be accessible only in this file (file scope).
On the other hand global variables have to be defined globally, persists (life is) throughout the program, scope is also throughout the program. This means such variables can be accessed from any function, any file of the program.
So if you have a global variable and u r distributing ur files as a library and you want others to not access your global variable, you may make it static by just prefixing keyword static (of course if same variable is not required in other files of yours).
