C++专题(一)

1.定义Person类,源程序文件名为penson.h

#include <iostream>
#include <string>

class Person
{
private:
    char Name[20];
    char Sex;
    int Age;

public:
    void SetData (char na[], char s, int a)
    {
        strcpy(Name, na);
        Sex = s;
        Age = a;
    }
    
    void GetName (char *na)
    {
        strcpy(na, Name);
    }

    char GetSex ()
    {
        return Sex;
    }

    int GetAge ()
    {
        return Age;
    }
};

　　定义对象的形式是: <类名> <对象列表>;如 Person a,b;

2.定义Person类,在类外定义成员函数,程序文件名为person.h.

#include <iostream>
#include <string>

class Person
{
private:
    char Name[20];
    char Sex;
    int Age;

public:
    void SetData (char [], char , int );
    void GetName (char *);
    char GetSex ();
    int GetAge ();
};

void Person::SetData (char na[], char s, int a)
{
    strcpy(Name, na);
    Sex = s;
    Age = a;
}

void Person::GetName (char *na)
{
    strcpy(na, Name);
}

char Person::GetSex ()
{
    return Sex;
}

int Person::GetAge ()
{
    return Age;
}

3.测试Person类.

#include "Person.h"

using namespace std;

void main ()
{
    Person a, *pa;
    char name[20];

    a.SetData("Cheng", 'F', 20);
    a.GetName(name);
    cout << "Name: " << name << endl;
    cout << "Sex " << a.GetSex() << endl;
    cout << "Age: " << a.GetAge() << endl;
    pa = &a;
    pa->SetData("Zhang", 'M', 18);
    pa->GetName(name);
    cout << "Name: " << name << endl;
    cout << "Sex: " << pa->GetSex() << endl;
    cout << "Age: " << pa->GetAge() << endl;
}

结果:

Name: Cheng

Sex: F

Age: 20

Name: Zhang

Sex: M

Age: 18

4.定义并测试长方形类CRect,长方形右左上角坐标(left, top)和右下角坐标(right, bottom)组成.

#include <iostream>
#include <cmath>

using namespace std;

class CRect
{
private:
    int left, top, right, bottom;

public:
    void setcoord (int , int, int, int );
    void getcoord (int *L, int *T, int *R, int *B)
    {
        *L = left;
        *T = top;
        *R = right;
        *B = bottom;
    }

    void print (void)
    {
        cout << "Area = " << abs(right - left) * abs(bottom - top) << endl;
    }
};

void CRect::setcoord (int L, int T, int R, int B)
{
    left = L;
    top = T;
    right = R;
    bottom = B;
}

void main (void)
{
    CRect r, rr;
    int a, b, c, d;
    r.setcoord(100, 300, 50, 200);
    r.getcoord(&a, &b, &c, &d);
    cout << "left=" << a << '	' << "top=" << b << endl;
    cout << "right=" << c << '	' << "bottom=" << d << endl;
    r.print();
    rr = r;
    rr.print();
}

结果:

left=100　　top=300

right=50　　bottom=200

Area=5000

Area=5000

5.自身类的对象不可以作为成员,而自身类的指针或引用可以作为类的成员.

class Obj
{
    int x;
    double y;
};

class Person
{
    char Name[20];
    char Sex;
    int Age;
    Obj obj1, obj2;                //可以
    Person a, b;                //不可以
    Person *pa;                //可以
};

6.当B类对象的指针或引用作为A类的成员时,如果B类的定义在A类之后,则在A类的定义之前,必须对B类做一个引用性说明.

class B;

class A
{
private:
    B *pb;

public:
    ...
};

class B
{
    ...
};

7.结构体变量的成员赋始值可以在定义结构体变量的同时进行,而对于类,如果其成员是公有的,才能在定义对象时进行赋初值.

class CRect
{
public:
    int left, top, right, bottom;
};

CRect r = {100, 300, 50, 200};

8.定义日期类,利用构造函数初始化数据成员.程序放在头文件date.h中

头文件：

#include <iostream>

using namespace std;

class Date
{
    int Year, Month, Day;

public:
    Date (int y = 2003, int m = 1, int d = 1)
    {
        Year = y;
        Month = m;
        Day = d;
    }

    void ShowDate (void)
    {
        cout << Year << '.' << Month << '.' << Day << endl;
    }
};

源文件:

#include "date.h"

void main (void)
{
    Date d1, d2(2008), d3(2008, 10), d4(2008, 10, 6);

    d1.ShowDate();
    d2.ShowDate();
    d3.ShowDate();
    d4.ShowDate();
}

结果:

2003.1.1

2008.1.1

2008.10.1

2008.10.6

Mark:

　　构造函数的特点如下:

　　1.构造函数是成员函数,函数体可写在类体内,也可写在类体外.

　　2.构造函数是特殊函数,该函数的名字与类名相同,不指定返回值类型.

　　3.构造函数可以重载,即可以定义多个参数个数不同的构造函数.

　　4.在创建对象时,系统自动调用构造函数.

　　在类体内定义构造函数的一般格式是: ClassName (<形参列表>) {...}

　　在类体外定义构造函数的一般格式是: ClassName::ClassName (<形参列表>) {...}

9.定义学生类,利用构造函数初始化数据成员,利用析构函数做清理工作.

头文件:

#include <iostream>
#include <cstring>

using namespace std;

class Student
{
    char Num[10], *Name;
    int Score;

public:
    Student (char *nump, char *namep, int score)
    {
        if (nump)
            strcpy(Num, nump);                        //在构造函数中,不需要动态申请Num成员的空间
        else
            strcpy(Num, "");
        if (namep)
        {
            Name = new char [strlen(namep)+1];        //在构造函数中,需要动态申请Name成员的空间
            strcpy(Name, namep);
        }
        else
            Name = NULL;
        Score = score;
        cout << "Constructor Called!
";
    }

    ~Student (void)
    {
        if (Name)
            delete [] Name;
        cout << "Destructor Called!
";
    }

    void Show (void)
    {
        cout << Num << '	' << Name << '	' << Score << endl;
    }
};

源文件:

#include "student.h"

void main (void)
{
    Student a("040120518", "George", 80);
    a.Show();
}

结果:

Constructor Called!

040120518　　George　　80

Destructor Called!

Mark:

　　析构函数的特点如下:

　　1.析构函数是成员函数,可在类体内定义,也可在类体外定义.

　　2.一般地,将析构函数定义成共有成员函数.

　　3.析构函数也是特殊函数,该函数的名字是类名前加~,用来与构造函数区分,该函数不指定返回值类型,没有参数.

　　4.一个类只能定义一个析构函数,即析构函数不允许重载.

　　5.析构函数可以被显示调用,也可以由系统自动调用.