1. 定义类employee,要求包含数据成员:name和salary,name要求用于存储职工的姓名,salary用于存储职工的工资,定义对应的默认构造函数,析构函数和赋值运算符,并定义类的对象a和b,要求b使用a进行赋值(即,b调用赋值运算符函数将对象a的值赋给b)。要求:默认构造函数、析构函数和赋值运算符中都需要加入输出语句
#include<iostream>
using namespace std;
class Employee
{
private:
char name[80];
int salary;
public:
Employee(char *s=" ",int a=0)
{
cout<<"Employee(char *s=" ",int a=0)"<<endl;
strcpy(name,s);
salary=a;
}
~Employee()
{
cout<<"called ~Employee()"<<endl;
}
Employee &Employee::operator=(const Employee &r)
{
cout<<"Employee &Employee::operator=(const Employee &r)"<<endl;
strcpy(name,r.name);
salary=r.salary;
return *this;
}
void print()
{
cout<<"name:"<<name<<" "<<"salary:"<<salary<<endl;
}
};
void main()
{
Employee a("jom",20),b;
a.print();
b=a;
b.print();
}
2. 在前一题的基础上定义company类,要求将employee的对象作为该类的数据成员,另外,company还包含一个数据成员name,用于存储公司的名称,定义对应的默认构造函数和析构函数,并且在主程序中定义company类的对象c,观察对象c的创建过程和析构过程。要求:默认构造函数、析构函数和赋值运算符中都需要加入输出语句
#include<iostream>
using namespace std;
class Employee
{
private:
char name[80];
int salary;
public:
Employee(char *s=" ",int a=0)
{
cout<<"Employee(char *s=" ",int a=0)"<<endl;
strcpy(name,s);
salary=a;
}
~Employee()
{
cout<<"called ~Employee()"<<endl;
}
Employee & operator=(const Employee &r)
{
cout<<"Employee &Employee::operator=(const Employee &r)"<<endl;
strcpy(name,r.name);
salary=r.salary;
return *this;
}
void print()
{
cout<<name<<" "<<salary<<endl;
}
};
class Company
{
Employee p;
char name[80];
public:
Company(Employee q,char *m=" "):p(q)
{
cout<<"Company(Employee q,char *m=" "):p(q)"<<endl;
strcpy(name,m);
}
~Company()
{
cout<<" ~Company()"<<endl;
}
void print()
{
p.print();
cout<<name<<endl;
}
};
void main()
{
Employee a("zhoudong",3200),b;
a.print();
b=a;
b.print();
Company c(b,"apple");
c.print();
}
3. 定义类fact,包含一个数据成员n,以及两个数据函数factn()和factsum(),factn()用于计算n!的值,而factsum()用于计算1!+2!+3!+……+n!的值,并将各个计算结果返回,要求在主函数中定义两个对象a(3)和b(5),调用相应的数据成员,并将计算结果输出
#include <iostream>
using namespace std;
class fact
{
int n;
public:
fact(int a)
{
n=a;
}
int factn()
{
cout<<"called int factn()"<<endl;
int j=1;
for(int i=1;i<=n;i++)
{
j*=i;
}
return j;
}
int factsum()
{
cout<<"called int factsum()"<<endl;
int j=1,sum=0;
for(int i=1;i<=n;i++)
{
j*=i;
sum=sum+j;
}
return sum;
}
void Print()
{
cout<<factn()<<" "<<factsum()<<endl;
}
};
void main()
{
fact b(5);
b.Print();
fact c(3);
c.Print();
}
第二篇:有关于类的定义赋值与调用总结 收藏
有关于类的定义赋值与调用总结 收藏
本类的成员函数:
定义: 类中声明: 返回值类型 函数名(参数表) ; //写了函数体就自动成为内联函数,这就
是隐式声明。或者也可以不写,
先在类中声明,在类外定义。
类外定义: 返回值类型 类名::函数名(参数表) {…}; //前面加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--; }
组合类_构造函数:
定义: 类中声明: 类名(形参表);
类外定义: 类名::类名(所有形参)
:内嵌对象1(形参表),内嵌对象2(形参表)...{ 利用子类对象进行母类的成员初
始化… }
//其实很简单,在第一个形参表中将所有要用到的参数全部写
全。然后在:后面将内嵌对象都列出来,参数写上。在函数体中
利用剩下的参数对剩下的母类成员赋值
例如: Line( Point xp1, Point xp2 );
Line::Line( Poine xp1, Point xp2 ):p1( xp1 ),p2( xp2 )
{ x = p1.GetX() – p2.GeX(); len = sqrt( x * x ); }
组合类_拷贝构造函数:
定义: 类中声明: 类名( 类名 &对象名);
类外定义: 类名::类名( 类名 &对象名 )
:内嵌对象1(形参表),内嵌对象2(形参表)...{ 利用子类对象进行母类的成员初始
化… }
//与组合类_构造函数的类似
例如: 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
类的对象数组:
定义: 类名 数组名[下标表达式];
调用: 数组名[下标].成员函数(参数表); //要记得是下标从0开始计算,创建时用默认的构造函数
来创建,此时初始值就派上了用场
例如: 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
指向类的静态函数的指针:
定义及赋值:类型说明符 (*指针名)(参数)=&类名::函数名 //静态类成员函数的指针是普通类型指针
访问: 指针名(参数)
例如: void (*gptr)() =& Point::GetC;
gptr();