Defining member functions outside the class definition
All of the classes that we have written so far have been simple enough that we have been able to implement the functions directly inside the class definition itself. For example, here’s our ubiquitous Date class:
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 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 | class Date{private: int m_Month; int m_Day; int m_Year; Date() {m_Month=0; m_Day=0; m_Year=0; } // private default constructorpublic: Date(int nMonth, int nDay, int nYear) { SetDate(nMonth, nDay, nYear); } void SetDate(int nMonth, int nDay, int nYear) { m_Month = nMonth; m_Day = nDay; m_Year = nYear; }
void resetDate()
{ m_Month=0; m_Day=0; m_Year=0;} int GetMonth() { return m_Month; } int GetDay() { return m_Day; } int GetYear() { return m_Year; }}; |
However, as classes get longer and more complicated, mixing the definition and the implementation details makes the class harder to manage and work with. Typically, when looking at a class definition (for an already written class), you don’t care how things are implemented — you want to know how to use the class, which involves only it’s definition. In this case, all of the implementation details just get in the way.
Fortunately, C++ provides a way to separate the definition portion of the class from the implementation portion. This is done by defining the class member functions outside of the class definition. To do so, simply define the member functions of the class as if they were normal functions, but prefix the class name to the function using the scope operator (::) (same as for a namespace).
Here is our Date class with the Date constructor and SetDate() function defined outside of the class definition. Note that the prototypes for these functions still exist inside the class definition, but the actual implementation has been moved outside:
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
28
29
30
31
32
| class Date{private: int m_Month; int m_Day; int m_Year; Date() // private default constructorpublic: Date(int nMonth, int nDay, int nYear); void SetDate(int nMonth, int nDay, int nYear); int GetMonth() { return m_nMonth; } int GetDay() { return m_nDay; } int GetYear() { return m_nYear; }};// Date constructorDate::Date(int nMonth, int nDay, int nYear){ SetDate(nMonth, nDay, nYear);}// Date member functionvoid Date::SetDate(int nMonth, int nDay, int nYear){ m_Month = nMonth; m_Day = nDay; m_Year = nYear;} |
This is pretty straightforward. Because access functions are often only one line, they are typically left in the class definition, even though they could be moved outside.
Here is another example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class Calc{private: int m_nValue;public: Calc() { m_nValue = 0; } void Add(int nValue) { m_nValue += nValue; } void Sub(int nValue) { m_nValue -= nValue; } void Mult(int nValue) { m_nValue *= nValue; } int GetValue() { return m_nValue; }}; |
becomes:
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
28
29
| class Calc{private: int m_nValue;public: Calc() { m_nValue = 0; } void Add(int nValue); void Sub(int nValue); void Mult(int nValue); int GetValue() { return m_nValue; }};void Calc::Add(int nValue){ m_nValue += nValue;}void Calc::Sub(int nValue){ m_nValue -= nValue;}void Calc::Mult(int nValue){ m_nValue *= nValue;} |
In this case, we left the default constructor in the class definition because it was so short.
Putting class definitions in a header file
In the lesson on header files, you learned that you can put functions inside header files in order to reuse them in multiple files or even multiple projects. Classes are no different. Class definitions can be put in header files in order to facilitate reuse in multiple files or multiple projects. Traditionally, the class definition is put in a header file of the same name as the class, and the member functions defined outside of the class are put in a .cpp file of the same name as the class. You may sometimes hear the term “one file, one class”, which alludes to the principle of putting classes in their own separate header/code files.
Here’s our Date class again, broken into a .cpp and .h file:
Date.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| #ifndef DATE_H#define DATE_Hclass Date{private: int m_Month; int m_Day; int m_Year; Date() { } // private default constructorpublic: Date(int nMonth, int nDay, int nYear); void SetDate(int nMonth, int nDay, int nYear); int GetMonth() { return m_nMonth; } int GetDay() { return m_nDay; } int GetYear() { return m_nYear; }};#endif |
Date.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| #include "Date.h"// Date constructorDate::Date(int nMonth, int nDay, int nYear){ SetDate(nMonth, nDay, nYear);}// Date member functionvoid Date::SetDate(int nMonth, int nDay, int nYear){ m_Month = nMonth; m_Day = nDay; m_Year = nYear;} |
Now any other header or code file that wants to use the date class can simply
#include "Date.h". Note that Date.cpp also needs to be compiled into any project that uses Date.h so the linker knows how Date is implemented. Don’t forget the header guards on the .h file!
In future lessons, most of our classes will be defined in the .cpp file, with all the functions implemented directly in the class definition. This is just for convenience and to keep the examples short. In real projects, it is much more common for classes to be put in their own code and header files.
0 comments: