开源中文网

您的位置: 首页 > C++语言 > 正文

linux下的c++(class base1)

来源:  作者:

类默认是私有,而结构体默认是公有
class fault is private, truct fault is public

 对象仅只包含类,构造器和成员函数属于类
object include data only, contructor and member_function blong to class

illustrate: there ere three files class.h class.c++ main1.c++
如果一个类中定义了多个构造函数,最好定义一个无参构造器,因为类继承时,调用的是无参构造器
list class.h
class tdate
{
private:
int month;
int day;
int year;
public:
//you must define a contructor which didn
't include parameters
//when have one or more contructor which have one or more parameters
tdate();
tdate(int t_month, int t_day, int t_year)
{
month=t_month;
day=t_day;
year=t_year;
}
//tdate(const tdate &obj)
//{}
void display();
};

list class.c++:

#include <iostream.h>
#include "class.h"
void tdate::display()
{
cout<<"the current month== "<<month<<" day== "<<day<<" year== "<<year<<endl;
}

list main1.c++:

#include <iostream.h>
#include "class.h"//need class tdate
int main()
{
tdate t1(12,30,2007);
tdate t2=tdate(12,31,2007);//impractical but allowed
tdate t3=t2;//invoking the copy contructor
//the method is can not running normal
//tdate t4(t1)
//it can running normal 
tdate t4(t2);
t1.display();
t2.display();
t3.display();
t4.display();
return 0;
}

now running it

[zhang@localhost c++]$ g++ -c class.c++
In file included from /usr/include/c++/3.2.2/backward/iostream.h:31,
                 from class.c++:1:
/usr/include/c++/3.2.2/backward/backward_warning.h:32:2: warning: #warning This
file includes at least one deprecated or antiquated header. Please consider using one of the 32 headers found in section 17.4.1.2 of the C++ standard. Examples
include substituting the <X> header for the <X.h> header for C++ includes, or <sstream> instead of the deprecated header <strstream.h>. To disable this warning
use -Wno-deprecated.
[zhang@localhost c++]$ g++ -o main1 main1.c++ class.o
In file included from /usr/include/c++/3.2.2/backward/iostream.h:31,
                 from main1.c++:1:
/usr/include/c++/3.2.2/backward/backward_warning.h:32:2: warning: #warning This
file includes at least one deprecated or antiquated header. Please consider using one of the 32 headers found in section 17.4.1.2 of the C++ standard. Examples
include substituting the <X> header for the <X.h> header for C++ includes, or <sstream> instead of the deprecated header <strstream.h>. To disable this warning
use -Wno-deprecated.
[zhang@localhost c++]$ ./main1
the current month== 12 day== 30 year== 2007
the current month== 12 day== 31 year== 2007
the current month== 12 day== 31 year== 2007

示例程序第一种对象构造方法虽然不实用,但他演示了临时对象(temporary object)的构造方法,这是因为等号右边生成了一个临时对象tdate,再赋给对象t1, 赋值完后就自动消失了,临时对象很麻烦,有可能为导致缺陷,所以我们应尽量避免产生临时对象

一定要记住,所有的参数都有缺省值时,类不能再声明一个无参构造器,如下面的代码将无法编译
public: 
tdate();
tdate(int t_month=0, int t_day=0, int t_year=0)
因为所有的参数都有缺省时,就相当于一个无参构造器了

调试类方法和函数相同
debug class method same as debug function

当用delete时,就会调用析构函数
it will invoking the 析构 function when use delete

指针类对象
pointer class object

创建动态类对象
tdate *object_p;//create object
p=new tdate;
通常用下面的方法
the above sentences equal to : tdate *object_p=new tdate;//create dynamic object
使用类对象
now can use the pointer object:
such as: object_p->display();//use object
删除类对象(此时会调用析构函数)
delete object_p;//delete object which invoking ~tdate()
在main1.c++中添加如下的语句就可以了
append follow lines on list main1.c++:
//create a dynamic object
tdate *object_p;
object_p=new tdate(1,1,2008);
//the above code equal to the follow line
//tdate *object_p=new tdate;
object_p->display();
delete object_p;
//it is over

在类中使用指针,和将该程序放在文件class.h中
use pointer in class and put it in class.h
class anyclass
{
private:
tdate *p;
public:
anyclass()
{p=new tdate(2,2,2008)}
~anyclass()
{//trace ~anyclass()'
s invoking
cout<<"delete the dynamic";
delete p;}
void display()
{
p->display();
}
};

在main1.c++中添加如下的行
append follow lines in main1.c++:
anyclass p;
p.display();

复制构造器
copy structor
here is a illustrate: list copy.c++
#include <iostream.h>
class test
{
private:
int x,y;
public:
test(int k1,int k2)
{x=k1;
 y=k2;
}
test()
{}
test(const test &p)
{x=p.x*2;
y=p.y+2;
}
void display();
//the follow is a friend function
friend void disp(test &p);
};
void test::display()
{
cout<<x<<" "<<y<<endl;
}
void disp(test &p)
{cout<<"this is a friend invoking";
cout<<p.x<<" "<<p.y<<endl;
}
int main()
{
test p1,p2(4,5);
p2.display();
//call overload operator function operator=()
p1=p2;//calls operator=()
test px(p2);//invoking the copystructor function and it only in defined
                                                                                
p1.display();
cout<<"this is the second invoking";
//p1(p2);this is wrong;
px.display();
test pk=p2;//invoking the copystructor function and it only in defined
cout<<"this is the third invoking";
//p1(p2);this is wrong;
pk.display();
disp(px);
pk.display();
disp(px);
return 0;
}

the output result:
4 5
4 5
this is the second invoking8 7
this is the third invoking8 7
this is a friend invoking8 7

当然我们可以定义一个重载操作符去验证p1=p2
also we can define a overload function to verify it(p1=p2)
you can applend follow lines in class test of copy.c++
void operator =(const test ©)
{
cout<<"call the overload function operator =()"<<endl;
x=copy.x;
y=copy.y;
}

从以上的例子可以知道,只有在类对象定义时赋给一个类对象才会调用拷贝构造函数,否则就会调用重载操作符函数
当然,你也可以调用这默认的重载操作符
of course, you can call the default operator=() function
以下还是operator=();但调用的是指针
list prompt.c++
#include <iostream.h>
#include <string.h>
class prompt
{
private:
char *p;
public:
prompt()
{}
prompt(const char *s)
{
p=new char[strlen(s)+1];
strcpy(p,s);
}
void operator=(const prompt ©);
~prompt()
{
cout<<"the delete function"<<endl;
delete []p;
}
void display();
};
void prompt::operator=(const prompt ©)
{
if(this==&copy)//avoid copying self to self
return;
delete []p;//delete old data
p=new char[strlen(copy.p)+1];
strcpy(p, copy.p);
}
void prompt::display()
{
cout<<p<<endl;
}
int main()
{
prompt pro1,pro2("hello are you good");
pro1=pro2;
pro2.display();
pro1.display();
return 0;
}
重载操作符可以调用私有变量

初始化列表
类对象只能用初始列表的方法来初始化
initialize list
class inilist
{
private:
prompt pros;// a class object data member
int x;
int y;
public:
//inilist(int c):pros("I am ok"),x(1){y=c}
//define out of class 
inilist(int c);
void display();
};
void inilist::display()
{
pros.display();
cout<<x<<endl;
}
inilist::inilist(int c):pros("I am ok"),x(1){y=c}

 再在main()里添加如下语句
 inilist inil1(8);
 再运行程序,结果为
 I am ok
1
8
the delete function

各种类对象
类对象作为函数参数
class c_funclass
{
private:
int x;
public:
c_funclass(int y):x(y)
{}
void display(c_function &dis)
{
dis.print();
}
void print();
};
void c_funclass::print()
{
cout<<x<<endl;
}
 类对象作为函数参数时,最好用引用或指针,这样可以节省很多的时间,如果不想修改指针,可以声明为const
 对象函数结果
 返回值为类对象(利用class prompt)
 prompt any_function()
 {
 prompt pro("are you ok");
 return pro;//return the copy of object 
}
在程序的其它地方用下列语句赋值
prompt pro1=any_function();
首先用函数any_function 构造了一个对象,再将对象返回,生成一个临时对象,用返回的临时对象构造pro1,最终要删除临时对象,这里调用了三个构造器和二个对象备份,如果用指针,只需构造一个对象。
实现代码如下:
prompt* any_function()
{
return new pro("are you ok");
}
prompt pro1=any_function();
当然,对象pro1必须显示的删除。
delete pro1;
而如果是返回对象的引用,效率会更高
prompt& any_function()
{
return today;
}
对象today必须在其它的地方生成
prompt &pro1=any_function();
使用指针的好处是,内存地址比大多数对象小。
在多次出现的复杂程序中,效率是主要的考虑因素

动态类对象数组
dynamical object array

prompt *p;
p=new prompt[6];
for(int i=0;i<6;i++)
p[i].display();
delete []p;
默认会为变量初始化为0

对象指针的数组
test *p[2];
所有指针类型为test *,但他并不生成test object, 如果想生成对象,在for循环中使用new
for(int i=0;i<2;i++)
{
p[i]=new test;
}
必须要主要,由于数组包含对象的指针,你要负责用new构造每个对象。调用每个对象的display()成员函数如下
for(int i=0;i<2;i++)
{
p[i]->display();
}

最后删除数组中的所有对象,由于数组包含对象的指针而不是对象本身,c++并不自动删除对象,也不调用任何类析构器,应显示地调用delete,以删除每个对象,如下for循环所示:
for(int i=0;i<2;i++)
{
delete p[i];
}
 
 对象数组作为数据成员
class xy
{
private:
test uu[10];
public:
.........
};

下一部分(class base2)是类继承
the next(class base2) is class inherit

 


以下是完整的详细源代码

list class.h

#include <string.h>
class tdate
{
private:
int month;
int day;
int year;
public:
//you must define a contructor which didn't include parameters
//when have one or more contructor which have one or more parameters
tdate();
tdate(int t_month, int t_day, int t_year)
{
month=t_month;
day=t_day;
year=t_year;
}
//tdate(const tdate &obj)
//{}
void display();
};
//use pointer in class and use object as pointer
class anyclass

class anyclass
{
private:
tdate *p;
public:
anyclass()
{p=new tdate(2,2,2008);}
void display()
{
p->display();
}
~anyclass()
{//trace the delete function
cout<<"invoking the delete function"<<endl;
delete p;}
};
class test
{
private:
int x,y;
public:
test(int k1,int k2);
test()
{}
test(const test &p);
void operator =(const test &copy);//calls operator=() member function
                                                                                
void display();
//the follow is a friend function
friend void disp(test &p);
};
class prompt
{
private:
char *p1;
public:
prompt()
{
}
prompt(const char *s)
{
p1=new char[strlen(s)+1];
strcpy(p1,s);
}
//void operator =(const prompt &copy);
~prompt()
{
cout<<"the delete function"<<endl;
delete []p1;
}
void display();
};
class inilist
{
private:
prompt pros;// a class object data member
int x;
int y;
public:
//initialize the class object and it the unique method
//inilist(int c):pros("I am ok"),x(1){y=c;}
inilist(int c);
//class object as function
void add(inilist &xy);
void display();
};

 

list class.c++


#include <iostream.h>
#include "class.h"
#include <string.h>//need strlen() strcpy()
void tdate::display()
{
cout<<"the current month== "<<month<<" day== "<<day<<" year== "<<year<<endl;
}
void test::display()
{
cout<<x<<" "<<y<<endl;
}
void disp(test &p)
{cout<<"this is a friend invoking";
cout<<p.x<<" "<<p.y<<endl;
}
test::test(const test &p)
{x=p.x*2;
y=p.y+2;
}
void test::operator =(const test &copy)
{
cout<<"overload operator function"<<endl;
x=copy.x;
y=copy.y;
}
test::test(int k1,int k2)
{x=k1;
 y=k2;
}
//void prompt::operator =(const prompt &copy)
//{
//if(this==&copy)//avoid copying self to self
//return;
//delete []p1;//delete old data
//p1=new char[strlen(copy.p1)+1];
//strcpy(p1, copy.p1);
//}
void prompt::display()
{
cout<<p1<<endl;
}
void inilist::display()
{
pros.display();
cout<<x<<endl;
cout<<y<<endl;
}
inilist::inilist(int c):pros("I am ok"),x(1){y=c;}
void inilist::add(inilist &xy)
{
x=xy.x+3;
}

 

list main1.c++

 

 

#include <iostream.h>
#include "class.h"//need class tdate, anyclass,test
//have pointer copy structor
#include <string.h>
void prompt1()
{
prompt pro1,pro2("hello are you good");
pro1=pro2;
pro2.display();
pro1.display();
}
int main()
{void tdate_test();//declaration tdate_test
tdate_test();//invoking tdate_test()
anyclass any;
any.display();
void copy_structor();//declaration copy_structor
//invoking copy_structor function
copy_structor();
//invoking the prompt();
prompt1();
//create a inilist object
inilist inil1(8);

inil1.display();
inil1.add(inil1);
inil1.display();
return 0;
}
void tdate_test()
{
tdate t1(12,30,2007);
tdate t2=tdate(12,31,2007);//impractical but allowed
tdate t3=t2;//invoking the copy contructor
//the method is can not running normal
//tdate t4(t1)
//the follow can running normal
tdate t4(t2);
t1.display();
t2.display();
t3.display();
t4.display();
//create a dynamic object
tdate *object_p;
object_p=new tdate(1,1,2008);
//the above code equal to the follow line
//tdate *object_p=new tdate;
object_p->display();
delete object_p;
}
void copy_structor()
{
test p1,p2(4,5);
p2.display();
//calls overloaded operator=() member function
p1=p2;//don't invoking the copystructor function
test px(p2);//invoking the copystructor function and it only in defined
                                                                                
p1.display();
cout<<"this is the second invoking";
//p1(p2);this is wrong;
px.display();
test pk=p2;//invoking the copystructor function and it only in defined
cout<<"this is the third invoking";
//p1(p2);this is wrong;
pk.display();
disp(px);
//define a dynamic array
test *p;
p=new test[2];
for(int i=0;i<2;i++)
{
p[i].display();
cout<<"dynamic array"<<endl;
}
delete[] p;
//define a dynamic pointer array
test *pp[2];
for(int i=0;i<2;i++)
pp[i]=new test;
for(int i=0;i<2;i++)
pp[i]->display();
//delete dynamic array
for(int i=0;i<2;i++)
delete pp[i];
}

Tags:linux下的c++(class base1)
相关文章列表:
关于开源中文网 - 联系我们 - 广告服务 - 网站地图 - 版权声明