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

缺乏、安全感 2024-04-19 13:46 49阅读 0赞

[http://blog.csdn.net/roy\_2008/archive/2008/05/10/2429812.aspx][http_blog.csdn.net_roy_2008_archive_2008_05_10_2429812.aspx]

本类的成员函数：

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

类外定义： 返回值类型 类名::函数名(参数表) \{…\};　　 //前面加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

指向类的非静态数据的指针：（公有）

定义：　　　类型说明符　类名:: \*指针名；

赋值：　　　指针名　=　&类名::数据成员名；

定义/赋值： 类型说明符　类名:: \*指针名=&类名::数据成员名　　　　//要找到成员的地址，就要有&号

访问：　　  对象名.\*类成员指针名      或者

对象指针名-> \*类成员指针名

例如：　　  int Test::\*vprt = &Test::value;           // 声明和初始化vPtr为Test类int型数据成员的指针

( \*prt).\*vptr                         //( \*prt)是对象指针名的另一个用法

指向类的非静态函数的指针：（公有）

定义：　　  类型说明符　(类名:: \*指针名) (参数);

赋值：　　  指针名　=　&类名::函数成员名;

定义/赋值：　类型说明符　(类名:: \*指针名) (参数) = &类名:: 函数成员名　//注意与上面的对比. 类的非靜态成员函数编译器是需要重新改写的，以加入对this的支持也就是说你看到的函数原型非不是最终的函数原型，所以它的指针就还有另外一个特性，即它所属的类。但是类的静态成员就不同，它没有this, 和普通函数一样

访问：　　  (对象名.类成员指针名)(参数表)        或者

(对象指针名-> \*类成员指针名)(参数表)

例如：　　　int ( Point:: \*p\_GetX) () = &Point::GetX();

(A. \*p\_Getx) ()

(p1-> \*p\_GetX) ();

指向类的静态数据的指针：

定义/赋值： 类型说明符 \*指针名=&类名:静态数据成员名　　　//与非静态成员相比，少了类名.有没有这种静态的指针都无所谓，因为它就是个普通类型的指针

访问：　　　\*指针名

例如：　　　int \*count = &Point::countP;

\*count

指向类的静态函数的指针：

定义及赋值：类型说明符 (\*指针名)(参数)=&类名::函数名    //静态类成员函数的指针是普通类型指针