|
Passion Administrator
Stubc Team - UID
- 1
- 帖子
- 1014
- 精华
- 9
- 积分
- 13714
- 所在学校
- 南京理工大学
- 所属专业
- 计算机科学与技术
- 阅读权限
- 200
- 性别
- 男
- 来自
- 江苏
- 在线时间
- 1360 小时
- 注册时间
- 2008-3-9
|
1#
大 中
小 发表于 2008-5-16 23:02 只看该作者
VC++/MFC 教程2(英文)
Lesson 2: C++ EssentialsIf you want to use Microsoft Visual C++, it helps a ton if youreally know C++. Everything is about classes. If you are used to plainC, you won't really see the big deal with classes until you use themfor a while. Let's review what you need to know about classes to getstarted with VC++.
A class is a structure for the most part. Let's work with anexample instead of me just telling you rules. Let's make a class torepresent a line. In the .h file you would define the class as follows:
class CLine
{
int m_nX1;
int m_nY1;
int m_nX2;
int m_nY2;
public:
// constructors
CLine();
CLine(int x1, int y1, int x2, int y2);
// destructor
~CLine();
// set the line data
void SetPoints(int x1, int y1, int x2, int y2);
// draw the line
void Draw();
}
A quick word about naming conventions. Class names usually start with 'C' and the member variables usually are prefixed by a 'm_'.Then in the microsoft way you will have a letter to let you know whatdata type the name is and then the name of the variable. Capitalize theletter of all new words in the name. Don't use underscores and stufflike that. I recommend this Microsoft standard (called Hungarian notation) since it is widely accepted and very easy to read. If you see m_pPoint, you would assume this is a member variable of a class that points (it is a pointer) to a point. If you see fData, you would assume that it is a floating-point value.
Back to our class. The int variables are the end points of the line. Note that they are before the 'public:' part. This means that a programmer using this class will not be allowed to manipulate these guys directly. They are not for 'public'use. The functions under the public statement are for public use. Thefirst three are called constructors. These functions are called anytimea new CLine class is created. Here are some examples when the are called:
// this calls CLine()
CLine MyLine;
// this is a pointer to a CLine class
CLine *pMyLine;
// this calls CLine()
pMyLine = new CLine;
// this is a pointer to a CLine class
CLine *pMyLine;
// this calls CLine(int x1, int y1, int x2, int y2)
pMyLine = new CLine(0,0,10,10);
// this calls CLine(int x1, int y1, int x2, int y2)
CLine MyLine(0,0,10,10);
All of these construct a line. Some initialize it to its default settings and others copy coordinates. The 'new' keyword is used to create new things in C++, like malloc in C. You need to call 'delete' for everything you say new to, like free in C. This goes for classes as well as other data types. I could allocate an array of 100 integers with:
// a pointer to some integers
int *pNumbers;
// make memory for 100 of them
pNumbers = new int[100];
// set the first element to 0
pNumbers[0]=0;
// set the last element to 99
pNumbers[99]=99;
// free the memory.
delete [] pNumbers;
Notice the [] after the delete. This is to tell the program to delete the entire array. If you say 'delete pNumbers;'you will only free memory for the first element. You will then be'leaking' memory. Memory leaks are when you forget to delete memory.This may end up crashing your computer if you use all the computersmemory.
Sorry, let's get back to the constructors for CLine. The code for these constructor functions which automagically get called when a new line is created will look like:
CLine::CLine()
{
m_nX1=0;
m_nX2=0;
m_nY1=0;
m_nY2=0;
}
CLine::CLine(int x1, int y1, int x2, int y2)
{
m_nX1=x1;
m_nX2=x2;
m_nY1=y1;
m_nY2=y2;
}
Notice that the function declaration is much like a regular 'C'function except that we put the class name and two colons in front ofthe function name (CLine::). One difference with constructorsis that they don't have a return value. This is the case fordestructors also. A destructor is the function which automagically getscalled when our CLine is deleted or goes out of scope. For instance:
// this is a pointer to a CLine class
CLine *pMyLine;
// this calls CLine()
pMyLine = new CLine;
// memory for the class is cleared up and ~CLine() is called
delete pMyLine;
{
// this calls CLine()
CLine MyLine;
}
// this '}' ends the section of the program where MyLine is
// valid. ~CLine() will be called. (MyLine goes out of 'scope')For our class, ~CLine() doesn't need to do anything.However, sometimes you may want to put your cleanup code here. Likedeleting any allocated memory in your class. Since we have nothing todo out function code is empty:
CLine::~CLine()
{
// do nothing
}
Let's fill in the other 2 functions.
void CLine::SetPoints(int x1, int y1, int x2, int y2)
{
m_nX1=x1;
m_nX2=x2;
m_nY1=y1;
m_nY2=y2;
return;
}
void CLine::Draw()
{
// psuedo code here, these are operating system
// functions to draw a line
MoveTo(m_nX1, m_nY1);
LineTo(m_nX2, m_nY2);
return;
}
How would I call these functions? Here are a couple of examples. One with pointers and one without.
CLine *pLine = new CLine(0,0,10,10);
pLine->Draw();
delete pLine;
CLine MyLine;
MyLine.SetPoints(0,0,10,10);
MyLine.Draw();
That's it for the class. Now this class can be used in otherclasses. You can imagine a CSquare class that has 4 Cline classes init:
class CSquare
{
CLine m_LineTop;
CLine m_LineLeft;
CLine m_LineBottom;
CLine m_LineRight;
//...
}
Or better yet, the point of all of this class stuff, you can use the CLineclass to make your own class. This is done a ton in Visual C. Lets sayyou wanted to draw lines in your program, and you thought the lineclass might be nice, but it is missing an important feature, it doesn'tlet you set the line color. Instead of writing a whole new class, youcan simple inherit the CLine class. This would look like this:
class CColorLine : public CLine
{
public:
void Draw(long color);
};
What's going on here? Well with this class we have all the functionality of our other class, but now we can use this other Draw() function which allows us to set the color. The CPP code would look like:
void CColorLine::Draw(long color)
{
// psuedo code here, these are operating system
// functions to draw a line
SetColor(color);
CLine::Draw();
return;
}
Now we have all the functionality of the other class but we added an extra function called Draw. But it's the same name as our other Draw! No matter. Cpp is smart enough to know that if you call Draw(color) to use the new function, but if you call Draw() it will use the old function. The strange part of the code may be CLine::Draw(). This just tells our program to call the base class's Draw function. We save ourselves from having to write that LineTo and MoveTo code again. Pretty cool, huh? Now we can do something like this:
CColorLine MyLine;
MyLine.SetPoints(0,0,10,10);
// assuming 0 is black, this will draw a black line.
MyLine.Draw(0);
Of course I'm leaving out a ton of aspects and things here. Likedefining operators, overriding functions, virtual functions, protectedand private members... the list goes on. You have enough to get startedthough.
|
搜索更多相关主题的帖子:
MFC 教程 英文
回帖既是一种美德，是对作者的鼓励，同时又为后来者推荐了好文章，何乐而不为呢？
|
