C++随笔（四）

浏览数：15 / 时间：2015年06月08日

1.成员函数的定义

两种形式：一种是在类声明中只给出成员函数的原型，函数体在类的外部定义。

void point::setposit(int a, int y)

{ x=a; y=b;}

int point::getx( )

{ return x; }

int point::gety( )

{ return y; }

另一种是内置函数：将成员函数定义在类内部，即内置函数，（一种是直接将函数定义在内部，将函数放在类定义体外，在函数定义体之前冠以“inline”，起到内置函数的作用。）

class point
{
    private:
        int x, y;
    public:
        void Setposit(int, int);
        int getx( );
        int gety( );
};
inline void point::setposit(int a, int y)
{    x=a;        y=b;    }
inline int point::getx( )
{    return x;    }
inline int point::gety( )
{    return y;    }

2.拷贝构造函数

拷贝构造函数是一种特殊的构造函数。用于依据已存在的对象建立一个新对象。

用户可以根据需要定义拷贝构造函数

系统也可以为类产生一个缺省的拷贝构造函数

#include <iostream.h>
class point
{
    int x,y;
public:
    point(int a,int b)
    { x=a; y=b; }
    void print()
    { cout<<x<<"  "<<y<<endl;}
};

int main()
{
    point p1(30, 40);
    point p2(p1);
    point p3=p1;
    p1.print();
    p2.print();
    p3.print();

    int x;
    cin >> x;
    return 0;
}

3.对象数组

若类中含有用户定义的构造函数，而且构造函数带有参数，则定义对象数组时，可通过初始值表进行赋值，例如3－13。

若类中含有构造函数，则定义对象数组时，可通过不带参数的构造函数或带有缺省参数的构造函数给对象数组赋值，例如3－14。

#include <iostream.h>
class exam
{
public:
    int x;
public:
    exam(int n)
    { x=n; }
    int get_x()
    { return x; }
};

int main()
{
    exam ob[4]={11,22,33,44};
    for(int i=0; i<4; i++)
        cout<<ob[i].get_x()<<‘ ‘;
    cout <<endl;

    return 0;
}

#include <iostream.h>
class point
{
private:
    int x,y;
public:
    point()
    { x=5; y=5; }
    point(int a,int b)
    { x=a; y=b; }
    int getx()
    { return x; }
    int gety()
    { return y; }
};

int main()
{
    point op(3, 4);
    cout<<"op x="<<op.getx()<<endl;
    cout<<"op y="<<op.gety()<<endl;
    point op_array[20];
    cout<<"op_array[1] x="<<op_array[1].getx()<<endl;
    cout<<"op_array[1] y="<<op_array[1].gety()<<endl;

    int x;
    cin >> x;
    return 0;
}

4.参数传递：

向函数传递对象时，通过传值调用传递给函数，即把对象的拷贝而不是对象本身传递给函数，函数中对对象的修改不影响调用该函数的对象本身。

也可以将对象的地址传递给函数。这时函数对对象的修改将影响调用该函数的对象本身。

观察例子进行比较

值不变

#include <iostream.h>
class tr
{
    int i;
public:
    tr(int n)
    {i=n;}
    void set_i(int n)
    {i=n;}
    int get_i()
    {return i;}
};

void sqr_it(tr ob)
{
    ob.set_i(ob.get_i()*ob.get_i());
    cout<<"copy of obj has i value of "<<ob.get_i()<<"\n";
}

int main()
{
    tr obj(10);
    sqr_it(obj);
    cout<<"But, obj.i is unchanged in main:"<<obj.get_i() << endl;

    return 0;
}

值变化

#include <iostream.h>
class tr
{
    int i;
public:
    tr(int n)
    {i=n;}
    void set_i(int n)
    {i=n;}
    int get_i()
    {return i;}
};

void sqr_it(tr& ob)
{
    ob.set_i(ob.get_i()*ob.get_i());
    cout<<"copy of obj has i value of "<<ob.get_i()<<"\n";
}

int main()
{
    tr obj(10);
    sqr_it(obj);
    cout<<"But, obj.i is unchanged in main:"<<obj.get_i()<<endl;

    return 0;
}

5.静态数据变量

在类定义中，若将一个数据成员说明为static，这种成员称为静态数据成员。无论建立多少个类的对象，都只有一个静态数据的副本。

静态数据属于类，因此可以使用

“类名::”

访问静态的数据成员。

静态数据成员不能在类中进行初始化，因为在类中不给它分配内存空间，必须在类外的其它地方提供定义。

#include <iostream.h>
class Student
{
    static int count;
    int StudentNo;
public:
    Student()
    {
        count++;
        StudentNo=count;
    }
    void print()
    {
        cout<<"Student"<<StudentNo<<" ";
        cout<<"count="<<count<<endl;
    }
};

int Student::count=0;

int main()
{
    Student Student1;
    Student1.print();
    cout<<"-----------------------\n";
    Student Student2;
    Student1.print();
    Student2.print();
    cout<<"-----------------------\n";
    Student Student3;
    Student1.print();
    Student2.print();
    Student3.print();
    cout<<"-----------------------\n";
    Student Student4;
    Student1.print();
    Student2.print();
    Student3.print();
    Student4.print();

    return 0;
}