有关于类的定义赋值与调用总结 收藏

有关于类的定义赋值与调用总结 收藏

本类的成员函数：

定义： 类中声明： 返回值类型 函数名(参数表) ; //写了函数体就自动成为内联函数，这就是隐式声明。或者也可以不写，先在类中声明，在类外定义。

类外定义： 返回值类型 类名::函数名(参数表) {…}; //前面加inline就表示内联函数，这是显式声明。

调用： 对象名.公有成员函数名(参数表) //在这里只能访问到类的公有成员 例如： 类中声明： void SetTime( int, int , int );

类外定义： inline void Clock::SetTime( int n, int s, int t )

{ Hour = h; Minute = m; Second = s; }

myClock.SetTime()

声明对象：

定义： 类名 对象名； 例如： Clock myClock;

本类的构造函数：

定义： 类中声明： 类名(参数表); //可以利用重载，定义无参、有参的构造函数，赋初始值。

类外定义： 类名::类名(参数表){…}

例如： Clock::Clock() { Hour = 0; Minute = 0; Second = 0 } // 无参的默认构造函数 Clock::Clock( int h, int m, int s )

{ Hour = h; Minute = m; Second = s; } // 有参的构造函数

本类的拷贝构造函数：

定义： 类中声明： 类名( 类名 &对象名);

类外定义： 类名( 类名 &对象名){ 类成员的初始化…成员名= 对象名.成员名}

//其实系统会自动生成一个默认的，它把具有构造函数初始值的数据成员都复制到新建立的对象中，相当于克隆。如果自己定义的话，它其实就是使用一个已经存在的的对象，去初始化同类的一个新对象

例如： Poine::Point( Point &p )

{ X = p.X; Y = p.Y; } //注意这里是用参数表中的对象成员来初始化新对象

使用： 类名 新对象( 旧对象 )

例如： Point A ( B ); //此时被自动调用

本类的析构函数：

定义： 类中声明： ~类名( );

类外定义： 类名::~类名( ){…} //注意：它无参数，函数体中做后续工作

例如： ~Clock() {…} ~Poing() { countP--; }

组合类_构造函数：

定义： 类中声明： 类名(形参表)；

类外定义： 类名::类名(所有形参)

:内嵌对象１(形参表)，内嵌对象２(形参表)...{ 利用子类对象进行母类的成员初

始化… }

//其实很简单，在第一个形参表中将所有要用到的参数全部写全。然后在:后面将内嵌对象都列出来，参数写上。在函数体中利用剩下的参数对剩下的母类成员赋值

例如： Line( Point xp1, Point xp2 );

Line::Line( Poine xp1, Point xp2 ):p1( xp1 ),p2( xp2 )

{ x = p1.GetX() – p2.GeX(); len = sqrt( x * x ); }

组合类_拷贝构造函数：

定义： 类中声明： 类名( 类名 &对象名); 类外定义： 类名::类名( 类名 &对象名 )

:内嵌对象１(形参表)，内嵌对象２(形参表)...{ 利用子类对象进行母类的成员初始

化… }

//与组合类_构造函数的类似

例如： Line:: Line ( Line &L ) : p1 ( L.p1 ), p2 ( L.p2 ) { len = L.len; }

本类的静态数据成员：

定义： 类中声明： static 数据类型 标识符；

类外赋值： 数据类型 类名::标识符 = 值； //注意它不属于任何对象，只能在类外赋初值。并且它要通过非内联函数来访问

调用： 类名∷标识符 例如： static int countP; int Point::countP = 0;

本类的静态函数成员：

定义： 类中声明： static 返回值类型 函数名(参数表) ;

类外定义： 返回值类型 类名::函数名(参数表) {…} ; //它一般用来访问本类的静态数据成员、静态函数成员

调用： 类名::函数名 或者 对象名.函数名 例如： static void add() { countP++; } Point::add() ; Mypoint.add();

类的友元函数：

定义： 类中声明： friend返回值类型 函数名(参数表) ;

类外定义： 返回值类型 函数名(参数表) {…}; //在类中用关键字friend修饰的非成员函数,

在它的函数体中可以访问类的私有和保护成员

调用： 函数名(参数表);

例如： friend float Fdist( Point &, Point & ); float Fdist( Point &p1, Point &p2 )

{ x = p1.X – p2.X; y = p2.Y – p2.Y; return sqrt ( x*x + y*y ); }

类的友元类：

定义： 类中声明： friend class 友类名； //友类的所有函数都可以访问本类的私有和保护成员,

但这种关系非传递、单向、非继承的

例如： friend class A;

类的对象指针：

定义： 类名 *对象指针名;

访问： 对象指针名->成员名(参数) 或者 ( *对象指针名).成员名(参数)

例如： Point p1; //先初始化类对象 Point *p_point; //再定义类的对象指针 p_point = &p1 //再赋值

p1->GetX(); //最后使用，就有如通过对象名访问一样

动态创建对象：

定义及赋值：类名 *对象指针名；

赋值： 对象指针名 = new 类名(构造函数参数表)； 定义/赋值： 类名 *对象指针名 = new类名(构造函数参数表)； 访问： 对象指针名->成员名(参数) 或者

( *对象指针名).成员名(参数) //和上面一样 销毁： delete 对象指针名

例如： Point *Ptr = new Point1( 1, 2 ) Delete Ptr

类的对象数组：

定义： 类名 数组名[下标表达式]；

调用： 数组名[下标].成员函数(参数表); //要记得是下标从０开始计算，创建时用默认的构造函数来创建，此时初始值就派上了用场

例如： Point A[2];

A[0].Move( i+10, i+20 );

动态创建对象数组：

定义及赋值：类名 *对象指针名 = new 类名[下标表达式] 调用： 对象指针名[下标].成员函数(参数表) 销毁：delete [] 对象指针名 例如：Point *Ptr = new Point[2]

Ptr[2].Move( 5, 10 ) Delete [] Ptr

指向类的非静态数据的指针：（公有） 定义： 类型说明符 类名:: *指针名；