1
00:00:01,560 --> 00:00:09,770
OK, so now we are going to talk about something that is going to be a little bit confusing, most likely,

2
00:00:09,780 --> 00:00:17,400
but nevertheless this very important topic, and it will actually be a change in the style in which

3
00:00:17,400 --> 00:00:22,170
we write our code and we're going to be using this style throughout the rest of the course.

4
00:00:23,680 --> 00:00:30,910
So and this style is going to be using multiple files for our code rather than just putting everything

5
00:00:30,910 --> 00:00:31,860
into one file.

6
00:00:33,150 --> 00:00:40,530
And it kind of has a lot to do with classes and object oriented programming that we've just started

7
00:00:40,530 --> 00:00:41,220
talking about.

8
00:00:42,510 --> 00:00:47,650
So like I said so far, we've been smashing all of our code into one file, right?

9
00:00:47,680 --> 00:00:57,000
So in this one file, we have our class definition, which was this right at the top of the file, we

10
00:00:57,000 --> 00:01:05,820
had our class car and then the definition, which included the defined prototypes of the member functions.

11
00:01:06,570 --> 00:01:15,300
And then we had our defined member variables, of course, and we separated it into public and private.

12
00:01:17,420 --> 00:01:24,270
Below this, we had our member function implementation, so we saw those prototypes up there.

13
00:01:24,950 --> 00:01:30,500
And these were the implementations right here, the constructor, and then we have the rest of these

14
00:01:30,500 --> 00:01:36,380
functions with the actual code that goes inside of them, the actual implementations.

15
00:01:37,280 --> 00:01:44,240
So that was in the middle of our file and at the bottom of our file, we defined our main function and

16
00:01:44,240 --> 00:01:45,740
implemented it right here.

17
00:01:45,770 --> 00:01:49,850
So this is something that you can refer to as the client code.

18
00:01:50,070 --> 00:01:56,420
Well, when I say client code, we're talking about like the user of the car, right?

19
00:01:56,420 --> 00:02:04,280
The person that creates the car or bias the car and uses it, not the engineers who blueprint the car.

20
00:02:04,310 --> 00:02:07,610
That kind of stuff is up here in these two sections.

21
00:02:10,110 --> 00:02:15,480
So what we're going to do now is we're going to break each one of these parts into three files because

22
00:02:15,480 --> 00:02:17,160
they have three distinct parts.

23
00:02:17,730 --> 00:02:19,170
We're going to separate it out.

24
00:02:20,100 --> 00:02:23,190
And this is going to be these files right here.

25
00:02:23,200 --> 00:02:31,290
So we have our blueprint class definition is going to be in a file called Khadka H.

26
00:02:31,860 --> 00:02:36,150
We have our implementations for the member.

27
00:02:36,150 --> 00:02:39,270
Functions are going to be in a file called card copy.

28
00:02:39,870 --> 00:02:44,580
And our main function will be in a client file called maned CBP.

29
00:02:45,930 --> 00:02:51,960
So first off, here, I when talk about this car dot h file, so this is something we refer to as the

30
00:02:51,960 --> 00:02:53,010
header file.

31
00:02:54,180 --> 00:02:58,600
So this file will contain the class definition slash blueprint.

32
00:02:59,070 --> 00:03:06,100
The name is the same as the class, so we see a Capital C car is the same as the class name here and

33
00:03:06,100 --> 00:03:06,990
those kind of small.

34
00:03:07,200 --> 00:03:13,620
We can't read but same name as the class, but then we have an extension h, which stands for header.

35
00:03:14,130 --> 00:03:16,290
And this is the header file.

36
00:03:16,860 --> 00:03:21,390
So all that stuff is going to go in its own special file, which is out of file.

37
00:03:22,900 --> 00:03:30,730
Next, we have the implementation file, so this file is going to contain all of the class member function

38
00:03:30,730 --> 00:03:33,600
implementation, so we saw the prototypes up here.

39
00:03:33,790 --> 00:03:39,370
These are all of our prototypes in the header file now, and we're going to put the actual implementation

40
00:03:39,370 --> 00:03:42,580
of them in a file called card copy.

41
00:03:43,030 --> 00:03:46,540
So the name will be the same as the class name right car.

42
00:03:46,540 --> 00:03:52,750
But instead of a dot h, we are doing a copy like we had before and this is what we stuffed everything

43
00:03:52,750 --> 00:03:53,020
into.

44
00:03:53,020 --> 00:03:54,880
Originally right was card of CBP.

45
00:03:56,190 --> 00:03:59,190
So our extension will be keep the same name as the class.

46
00:04:02,550 --> 00:04:10,980
So this third file is going to be what we consider the client file, the client file is just some code

47
00:04:10,980 --> 00:04:14,610
that has an an interest in using the class.

48
00:04:14,940 --> 00:04:19,980
But you know it is not the engineer portion, right?

49
00:04:20,010 --> 00:04:23,760
It has no concern about how all of these functions operate.

50
00:04:24,210 --> 00:04:26,200
It's just going to use them, right?

51
00:04:26,220 --> 00:04:34,830
It's somebody built a car for a purpose, and this code right here is putting that to use.

52
00:04:34,860 --> 00:04:35,220
Right?

53
00:04:35,880 --> 00:04:41,340
So creating car is driving, the car is changing the paint, getting the odometer, all of that stuff.

54
00:04:42,030 --> 00:04:46,980
So this is what we can consider client code and the client file.

55
00:04:47,370 --> 00:04:55,380
Since we have main function in here, we're going to call this main step, but it doesn't doesn't always

56
00:04:55,380 --> 00:04:57,690
have to be made up for client code.

57
00:04:57,690 --> 00:04:59,100
You can have multiple files.

58
00:05:00,230 --> 00:05:06,180
Just, of course, having our main function right in this file and we don't have any other files or

59
00:05:06,270 --> 00:05:10,180
other client files at the moment, and it doesn't have to just be a main function here.

60
00:05:10,180 --> 00:05:12,450
It could be a main and other functions as well.

61
00:05:14,270 --> 00:05:22,700
So this is meant for a user or developer who wants to use the class, right, so it's someone who is

62
00:05:22,700 --> 00:05:28,490
interested in using the car class just like we would with a string class or something like that.

63
00:05:28,910 --> 00:05:35,720
You notice when if we include a string, we're going to use a string right and we might use string lengths

64
00:05:35,720 --> 00:05:36,400
and all that stuff.

65
00:05:36,410 --> 00:05:37,790
Now we are using a car.

66
00:05:37,820 --> 00:05:45,740
So this client code is going to have to include the car class.

67
00:05:45,740 --> 00:05:46,850
So we will see that.

68
00:05:47,450 --> 00:05:52,910
And this next part right here where I jump in to the editor and I'll explain some other things.

69
00:05:54,440 --> 00:06:04,090
So I head over here to a visual studio code, and we have our main CPI file card out CP and card up

70
00:06:04,100 --> 00:06:05,060
each file in here.

71
00:06:05,720 --> 00:06:11,570
So you've seen this already, but I'm going to explain this stuff up here.

72
00:06:11,870 --> 00:06:21,320
So just like we include string to access some stuff with strings, right?

73
00:06:21,320 --> 00:06:22,970
We got to create some string types.

74
00:06:23,150 --> 00:06:24,220
We don't have any.

75
00:06:24,230 --> 00:06:27,620
I'm not making any string types in here, but I just included as an example.

76
00:06:29,540 --> 00:06:34,160
Just like we include string, we're going to have to include car, although it looks a little different,

77
00:06:34,160 --> 00:06:34,460
right?

78
00:06:34,850 --> 00:06:39,860
Something that I want to say right off the bat, though, is that when we are doing this, we are including

79
00:06:39,860 --> 00:06:40,520
string.

80
00:06:41,210 --> 00:06:45,440
We're actually including the header file.

81
00:06:45,800 --> 00:06:51,740
Just like car dot h string has a header file and that is what we're doing.

82
00:06:51,920 --> 00:06:53,570
We're actually including string.

83
00:06:54,210 --> 00:06:57,320
And you can actually include something that string on h.

84
00:06:57,650 --> 00:07:02,780
This is kind of more of a C programming language concept, but you know, we don't have to put the data

85
00:07:02,780 --> 00:07:04,130
and we can just use this syntax.

86
00:07:04,130 --> 00:07:06,830
But really, this is like a header file that we're including.

87
00:07:09,200 --> 00:07:16,610
So this include Khadka age is pretty much the same thing as this, including the string header file,

88
00:07:16,610 --> 00:07:25,040
but we're including our own header file since we're not including a se t.l a standard template library.

89
00:07:27,710 --> 00:07:33,620
Kind of header file here, we have to put quotations because we created this, it's not part of the

90
00:07:33,620 --> 00:07:35,810
standard template library of C++.

91
00:07:36,470 --> 00:07:38,750
This is our own header file.

92
00:07:39,110 --> 00:07:41,440
Therefore, we have to surround it with quotes.

93
00:07:41,450 --> 00:07:43,070
It's just a little bit different syntax.

94
00:07:43,070 --> 00:07:49,190
We're not going to use the less than greater than we're going to use these quotes to it whenever we

95
00:07:49,190 --> 00:07:53,510
want to include our own header files for our class definitions.

96
00:07:55,410 --> 00:07:59,010
And you might be thinking, OK, well, we include Carter H.

97
00:07:59,040 --> 00:08:02,220
Do we not have to include Carter ACP?

98
00:08:02,460 --> 00:08:02,880
Well, yeah.

99
00:08:02,880 --> 00:08:06,210
For now, we're not going to have to include Carter CP.

100
00:08:06,210 --> 00:08:11,010
You don't have to include any other stringed CP or something, right?

101
00:08:11,280 --> 00:08:12,900
You're just including string.

102
00:08:12,900 --> 00:08:14,090
And this includes string.

103
00:08:14,100 --> 00:08:16,500
It just happens to be including the header file.

104
00:08:16,920 --> 00:08:17,790
That's what it does.

105
00:08:18,390 --> 00:08:20,970
So we're only having interests, including the header file.

106
00:08:20,970 --> 00:08:26,280
The compilation and linking process will handle the rest of putting these three files together when

107
00:08:26,280 --> 00:08:27,570
we get an executable.

108
00:08:29,150 --> 00:08:34,190
So let me move on to the next one card out, C.P. So just like mean gossip.

109
00:08:34,220 --> 00:08:41,060
We also have to include the header file in our implementation file, the card CPP file.

110
00:08:41,840 --> 00:08:45,290
That is because we need access to the car blueprint, right?

111
00:08:45,290 --> 00:08:48,680
The car definition to be able to implement these functions.

112
00:08:49,700 --> 00:08:54,560
So we're going to use the quotes and include our Carter H header file.

113
00:08:55,770 --> 00:09:00,900
Another thing I want to mention about String is that if you're using strings in your code, you might

114
00:09:00,900 --> 00:09:07,140
as well just include string because you notice before that, I didn't always have to include string

115
00:09:07,170 --> 00:09:13,380
to use strings in my code, but that is kind of a compiler specific thing.

116
00:09:13,620 --> 00:09:21,660
I think men GW handles that in a specific way, and iOS Dream also has some stuff with strings, so

117
00:09:21,660 --> 00:09:24,480
you might be able to get away with just including Io stream.

118
00:09:25,110 --> 00:09:31,770
But if you want your code to not really be compiler dependent and be more flexible, you should include

119
00:09:31,770 --> 00:09:36,750
string at all times whenever you're using strings at all in your code.

120
00:09:37,200 --> 00:09:41,070
So I recommend putting this include string in there as well.

121
00:09:41,250 --> 00:09:45,030
Of course, I don't necessarily need it in Maine because I'm not directly including them.

122
00:09:45,510 --> 00:09:48,230
I'm not like using strings so I can get this out of here.

123
00:09:49,760 --> 00:09:54,740
Plus, ice cream has some things that have to do with strings like we can just print out the strings

124
00:09:54,740 --> 00:09:55,310
here and stuff.

125
00:09:57,590 --> 00:10:01,010
So let's go ahead and head back here.

126
00:10:01,100 --> 00:10:03,260
So we're pretty this is pretty much done here.

127
00:10:03,590 --> 00:10:06,370
You know, this is just everything that you saw before.

128
00:10:06,380 --> 00:10:08,090
It's all the function implementations.

129
00:10:08,100 --> 00:10:11,060
This all just goes in its own file called the card CPP.

130
00:10:11,300 --> 00:10:17,840
And the one main thing to point out right now, even though it wasn't discussed in the slideshow, was

131
00:10:17,840 --> 00:10:24,260
that we need to include the car header file here as well, just like in made CBB.

132
00:10:25,070 --> 00:10:26,770
So let's jump over to Carter Page.

133
00:10:26,780 --> 00:10:29,000
So this has some other interesting stuff.

134
00:10:29,030 --> 00:10:35,420
Notice that I'm also including string here because I'm using strings, so just kind of reiterating that

135
00:10:35,420 --> 00:10:35,750
point.

136
00:10:36,620 --> 00:10:38,290
But what is this stuff up here?

137
00:10:38,300 --> 00:10:38,580
OK?

138
00:10:38,600 --> 00:10:40,120
This is kind of interesting.

139
00:10:40,130 --> 00:10:43,220
These things you might have seen them before, you might not have.

140
00:10:43,790 --> 00:10:48,500
These are called macro guards or pre-processing directives.

141
00:10:49,850 --> 00:10:56,510
So what this actually stands for up here is, if not defined, it says if in death.

142
00:10:57,630 --> 00:10:57,960
Right.

143
00:10:58,680 --> 00:11:05,550
So if indeed, if that stands for if not defined here, what we do is just kind of a syntax thing.

144
00:11:05,550 --> 00:11:08,010
We put all caps car underscore.

145
00:11:08,300 --> 00:11:12,420
You do not have to put it like this, but this is kind of the standard.

146
00:11:13,380 --> 00:11:17,940
So this is the name of our class and the name of our file right there because they're both supposed

147
00:11:17,940 --> 00:11:18,810
to be the same name.

148
00:11:19,560 --> 00:11:21,300
So that's why we put the capital car.

149
00:11:21,330 --> 00:11:27,420
We do an underscore and then an h to specify that this is a header file and it's really defining some

150
00:11:27,420 --> 00:11:32,070
sort of symbol, some sort of constant for this header file.

151
00:11:33,980 --> 00:11:35,750
And why do we need to do this?

152
00:11:35,960 --> 00:11:41,030
Also notice down here says, and if this is another part of this processing directive thing.

153
00:11:43,020 --> 00:11:44,600
So why do we need to do this?

154
00:11:44,610 --> 00:11:52,590
Well, the reason is because if we start including multiple files like, let's say, we include another

155
00:11:52,590 --> 00:11:58,740
file in here that we made, like maybe we want to make a tire class for the car and we have a private

156
00:11:58,740 --> 00:12:02,340
data of its type tire our own abstract data type.

157
00:12:02,820 --> 00:12:07,200
So if we want to make a private member here, we ought to include Dot H.

158
00:12:08,100 --> 00:12:16,500
The problem is is if we include if we go to Maine, we include car dot h and we also include tire age

159
00:12:16,500 --> 00:12:20,460
and here as well because we want to also just make tires or something.

160
00:12:22,440 --> 00:12:30,780
There will be this problem in the compilation and linking process, and it will be this double include

161
00:12:30,780 --> 00:12:38,610
problem is basically going to just try and process do pre processing of the header file twice.

162
00:12:39,960 --> 00:12:45,780
Because it's basically going to it'll go in here, it'll be oh, tired out is is here and it will jump

163
00:12:45,780 --> 00:12:46,860
over and check out tired.

164
00:12:47,640 --> 00:12:50,120
OK, you included tired of age.

165
00:12:50,130 --> 00:12:53,400
Let's just hypothetically say I have tired of age here.

166
00:12:55,170 --> 00:12:57,090
I could just put that here just in case.

167
00:12:57,090 --> 00:12:59,940
But so something like this.

168
00:13:01,050 --> 00:13:03,090
So the typing is still quite a struggle.

169
00:13:03,450 --> 00:13:05,070
So I include tired, right?

170
00:13:05,070 --> 00:13:06,630
And it's like, oh, tired at age.

171
00:13:06,630 --> 00:13:07,350
Let me check that out.

172
00:13:07,350 --> 00:13:09,630
Jumps over to the tired of file checks that out.

173
00:13:11,220 --> 00:13:17,280
And then what it does is goes in here and it has.

174
00:13:20,260 --> 00:13:29,370
Let's say include tired age, and then it comes over here, and it's like.

175
00:13:30,060 --> 00:13:33,000
So I guess I what I should really start out with is, let's say we're in Maine, right?

176
00:13:33,040 --> 00:13:35,160
It is this include Carter, actually, because of here.

177
00:13:35,160 --> 00:13:36,480
It's like, Ooh, Carter h.

178
00:13:36,480 --> 00:13:37,770
Oh, tired, I was there.

179
00:13:37,770 --> 00:13:39,530
I go, check that out, OK?

180
00:13:39,540 --> 00:13:44,160
And I then I come back and I processed Carter H and I go over here.

181
00:13:46,620 --> 00:13:48,240
You know, and I have tired of age.

182
00:13:48,630 --> 00:13:53,810
It's already process, tired of age, you know, and it doesn't really matter necessarily the order.

183
00:13:53,820 --> 00:13:55,410
It can still be problematic.

184
00:13:55,740 --> 00:14:04,170
It's just going to try and process this tired age again so that that becomes a serious problem.

185
00:14:04,680 --> 00:14:13,080
And it still is good to have these pre processing directives, even if we don't have Carter age or sorry,

186
00:14:13,080 --> 00:14:14,340
we don't have time to age.

187
00:14:16,530 --> 00:14:21,090
It really just protects us with all of this including stuff, because if we start including stuff in

188
00:14:21,090 --> 00:14:27,810
different places, you know, we're including some stuff in the client code or including some things

189
00:14:27,810 --> 00:14:30,180
in here or including some things in here.

190
00:14:30,810 --> 00:14:32,490
It really just protects us.

191
00:14:32,490 --> 00:14:39,780
So there's not this like double pre-processing of the same header file multiple times that will lead

192
00:14:39,780 --> 00:14:47,940
to linker errors and quite often linker errors that you see will be very ambiguous and hard to understand.

193
00:14:47,970 --> 00:14:51,360
So the linker is part of the compilation process, right?

194
00:14:51,600 --> 00:14:55,980
The files get compiled and then after they're compiled, they get linked together.

195
00:14:56,370 --> 00:14:56,760
So.

196
00:14:58,320 --> 00:15:02,880
That's just something that we might talk about more later, but right now, I'm not incredibly important

197
00:15:02,880 --> 00:15:03,330
to you.

198
00:15:03,510 --> 00:15:09,420
But what we need to do is now compile all three of these, so I'm going to go ahead and show you how

199
00:15:09,420 --> 00:15:09,890
to do that.

200
00:15:09,900 --> 00:15:17,550
So just remember that these pre-processing directives are important to put inside the header files because

201
00:15:17,550 --> 00:15:23,750
they to protect us against that kind of double inclusion, double processing thing.

202
00:15:25,210 --> 00:15:25,920
Get one last thing.

203
00:15:25,920 --> 00:15:26,940
I guess this in-depth.

204
00:15:27,330 --> 00:15:31,050
Basically, what happens if I can specifically describe to you what happens is?

205
00:15:32,390 --> 00:15:40,220
We see this, if not defined car age, and let's say that it's not defined yet, then it'll say define

206
00:15:40,220 --> 00:15:40,840
car age.

207
00:15:40,850 --> 00:15:43,400
So if it's not defined already, then define it.

208
00:15:43,550 --> 00:15:48,380
If it's not processed already, then we'll go ahead and we will process it.

209
00:15:48,830 --> 00:15:54,070
Otherwise, we would jump over all of this code in here and go straight down to this.

210
00:15:54,080 --> 00:15:57,760
And if so, it would not do anything in between.

211
00:15:57,790 --> 00:16:01,400
It would not do any processing in between here if it's already defined right.

212
00:16:01,400 --> 00:16:07,670
That prevents us from doing that, like double processing with the includes and stuff like that.

213
00:16:09,560 --> 00:16:16,790
OK, so let's go ahead and see how we would compile this now, because previously we've just kind of.

214
00:16:18,620 --> 00:16:21,710
Compile the one file, right, and how do we do that?

215
00:16:21,840 --> 00:16:28,190
Instead, D-plus Plus and you know, it was like hard copy Dashiell out, easy, something like that,

216
00:16:28,190 --> 00:16:28,430
right?

217
00:16:29,150 --> 00:16:38,450
All we have to do now is to compile not only car first card copy, but main CPB afterwards.

218
00:16:38,960 --> 00:16:42,740
So you do not need to compile the header files.

219
00:16:43,070 --> 00:16:44,660
You don't need to compile.

220
00:16:45,290 --> 00:16:46,340
I stream.

221
00:16:46,340 --> 00:16:47,120
Do you write?

222
00:16:47,130 --> 00:16:48,940
It just includes a header for you.

223
00:16:48,940 --> 00:16:52,100
It just gives you access to this other library.

224
00:16:52,100 --> 00:16:56,330
The link is going to handle all this stuff for you, the compiler and linker.

225
00:16:58,420 --> 00:16:59,720
So you don't have to deal with that.

226
00:16:59,740 --> 00:17:06,520
You know, it basically evaluates all these symbols, which we, you know, we'll call them, and it

227
00:17:06,520 --> 00:17:08,700
will correctly put together your executable.

228
00:17:08,710 --> 00:17:15,550
We just need to make sure that we're putting the G Plus Plus compiler statement in the correct syntax

229
00:17:15,550 --> 00:17:16,120
in order.

230
00:17:16,390 --> 00:17:23,320
So we're going to go ahead and put this card CP and then we're going to go ahead and put this main CP.

231
00:17:23,330 --> 00:17:25,000
We do not need the card on h.

232
00:17:26,140 --> 00:17:28,990
So we're going to compile all of the CP files.

233
00:17:28,990 --> 00:17:35,410
So if you were to have more client files or you had another class like, let's say, we had the TYR

234
00:17:35,410 --> 00:17:43,660
class, so we had or h and tired CP, you would not compile Typekit h, but you would have to include

235
00:17:43,660 --> 00:17:45,360
tired CP here.

236
00:17:46,930 --> 00:17:53,800
So you could just put tired CBP then car to keep in mind asleep and then we can leave this dash if we

237
00:17:53,800 --> 00:17:55,390
want to name an output file.

238
00:17:55,780 --> 00:17:57,430
So let's go ahead and compile this.

239
00:17:59,070 --> 00:18:06,750
So it looks like everything is all good, and I will go ahead and run it just to show you that this

240
00:18:06,750 --> 00:18:10,540
has the same output as what we've seen in the lectures before.

241
00:18:10,560 --> 00:18:14,370
So if we go over to Main, we see what is expected here at car.

242
00:18:14,370 --> 00:18:16,610
One miles is 40000, right?

243
00:18:16,660 --> 00:18:18,270
That's what we're getting off the odometer.

244
00:18:18,270 --> 00:18:19,650
That's what was set right here.

245
00:18:20,070 --> 00:18:23,250
Car to get odometer is 10000 miles.

246
00:18:23,670 --> 00:18:32,940
Then we notice that we have the jet fuel was 12 because that was kind of hard coded here in the constructor.

247
00:18:33,690 --> 00:18:34,470
Then we have.

248
00:18:35,310 --> 00:18:40,830
Blue Bell, excuse me, blue for the paint, for the get paint and then.

249
00:18:44,010 --> 00:18:49,290
We sat down at eight thirty seven and we get the odometer says eight, thirty seven and then we get

250
00:18:49,290 --> 00:18:54,060
the paint after this changing to black and this is black, so everything works the exact same.

251
00:18:54,060 --> 00:19:00,630
What it did was it went ahead and went through all of these files and compiled and linked them correctly

252
00:19:00,630 --> 00:19:06,930
into that executable, just as if we had only been using a one file like hard copy.

253
00:19:08,700 --> 00:19:12,210
So this is probably a lot to take in.

254
00:19:12,300 --> 00:19:16,770
This is a totally new style of programming, but this is kind of the way to do it.

255
00:19:17,040 --> 00:19:24,420
This is the real software engineering way to organize your files in C++, and so that's why we're going

256
00:19:24,420 --> 00:19:25,290
to start using it.

257
00:19:25,710 --> 00:19:29,520
It'll become easier as you practice it and use this more.

258
00:19:30,750 --> 00:19:34,890
It'll become fairly straightforward that whenever you're making a class, you're just going to make

259
00:19:34,890 --> 00:19:39,510
a header file that has this stuff in it with the definitions.

260
00:19:39,840 --> 00:19:46,320
Then you'll make another special file that has the same name, but it'll be dust up and it will have

261
00:19:46,320 --> 00:19:49,260
all of the member function implementations in here.

262
00:19:50,460 --> 00:19:53,910
And then you can make a client file that will include this header.

263
00:19:53,910 --> 00:19:57,620
And now you have access to the car class and you can start doing whatever you want.

264
00:19:57,630 --> 00:20:01,560
So we'll have access to whatever class we made with the header and the implementation.

265
00:20:02,970 --> 00:20:06,210
OK, so that's all I have for this lecture.

266
00:20:06,450 --> 00:20:12,300
In the next lectures, we're going to start using this stuff and we'll come up with some interesting

267
00:20:12,300 --> 00:20:13,410
practice problems.

268
00:20:14,220 --> 00:20:18,690
So just go over this as many times as you need to to understand it.

269
00:20:18,960 --> 00:20:26,430
We're going to be talking more about classes and using this style, and there's a lot more to go over

270
00:20:26,460 --> 00:20:28,320
with object oriented programming.

271
00:20:28,320 --> 00:20:34,460
So we're just going to keep adding things into this header file and the implementation.

272
00:20:34,470 --> 00:20:40,770
We're going to talk about overloading operators and stuff like that in the near future and then using

273
00:20:40,770 --> 00:20:45,240
classes together like we're going to have several classes, not just car.

274
00:20:45,540 --> 00:20:50,910
We'll have classes that relate to each other and they have a special relationship and and we're going

275
00:20:50,910 --> 00:20:53,220
to talk about those concepts as well.

276
00:20:54,390 --> 00:20:54,650
All right.

277
00:20:54,660 --> 00:20:56,730
So with that, I will see you in the next lecture.