类的定义
类可以看做是一种数据类型,类这种数据类型是一个包含成员变量和成员函数的集合。类的成员变量和普通变量一样,也有数据类型和名称,占用固定长度的内存。但是,在定义类的时候不能对成员变量赋值,因为类只是一种数据类型或者说是一种模板,本身不占用内存空间,而变量的值则需要内存来存储。
类的成员函数也和普通函数一样,都有返回值和参数列表,它与一般函数的区别是:成员函数是一个类的成员,出现在类体中,它的作用范围由类来决定;而普通函数是独立的,作用范围是全局的,或位于某个命名空间内。实例1:
#include <iostream>using namespace std;//类通常定义在函数外面class Student{public://类包含的变量char *name;int age;float score;//类包含的函数void say(){cout << name << "的年龄是" << age << ",成绩是" << score << endl;}};int main(){//创建对象Student stu;stu.name = "小明";stu.age = 15;stu.score = 92.5f;stu.say();return 0;}
实例1中在类体中定义了成员函数,也可以只在类体中声明函数,在类体中直接定义函数时,不需要在函数名前面加上类名,因为函数属于哪一个类是很明显的。但当成员函数定义在类外时,就必须在函数名前面加上类名予以限定。::被称为域解析符(也称作用域运算符或作用域限定符),用来连接类名和函数名,指明当前函数属于哪个类。
成员函数必须先在类体中作原型声明,然后在类外定义,也就是说类体的位置应在函数定义之前。
class Student{public://成员变量char *name;int age;float score;//成员函数void say(); //函数声明};//函数定义void Student::say(){cout << name << "的年龄是" << age << ",成绩是" << score << endl;}
虽然 C++ 支持将内联函数定义在类的外部,但建议将函数定义在类的内部,这样它会自动成为内联函数,何必费力不讨好地将它定义在类的外部呢,这样并没有任何优势。类的定义可以使用指针形式,并使用“->”初始化,实例2:
#include <iostream>using namespace std;class Student{public:char *name;int age;float score;void say(){cout << name << "的年龄是" << age << ",成绩是" << score << endl;}};int main(){Student *pStu = new Student;pStu->name = "小明";pStu->age = 15;pStu->score = 92.5f;pStu->say();delete pStu; //删除对象return 0;}
实例2在堆上创建对象,需要使用new关键字,在栈上创建出来的对象都有一个名字,比如 stu,使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了,它在堆上分配内存,没有名字,只能得到一个指向它的指针,所以必须使用一个指针变量来接收这个指针,否则以后再也无法找到这个对象了,更没有办法使用它。也就是说,使用 new 在堆上创建出来的对象是匿名的,没法直接使用,必须要用一个指针指向它,再借助指针来访问它的成员变量或成员函数。
类成员的访问权限:
C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限,它们分别表示公有的、受保护的、私有的,被称为成员访问限定符。所谓访问权限,就是你能不能使用该类中的成员。C++ 中的 public、private、protected 只能修饰类的成员,不能修饰类,C++中的类没有共有私有之分。在类的内部(定义类的代码内部),无论成员被声明为 public、protected 还是 private,都是可以互相访问的,没有访问权限的限制。在类的外部(定义类的代码之外),只能通过对象访问成员,并且通过对象只能访问 public 属性的成员,不能访问 private、protected 属性的成员。见实例3:
#include <iostream>using namespace std;//类的声明class Student{private: //私有的char *m_name;int m_age;float m_score;public: //共有的void setname(char *name){m_name = name;}void setage(int age){m_age = age;}void setscore(float score){m_score = score;}void show(){cout << m_name << "的年龄是" << m_age << ",成绩是" << m_score << endl;}};int main(){//在栈上创建对象Student stu;stu.setname("小明");stu.setage(15);stu.setscore(92.5f);stu.show();//在堆上创建对象Student *pstu = new Student;pstu->setname("小红");pstu->setage(16);pstu->setscore(96);pstu->show();return 0;}
成员变量大都以m_开头,这是约定成俗的写法,不是语法规定的内容。以m_开头既可以一眼看出这是成员变量,又可以和成员函数中的形参名字区分开。实例3中的m_name、m_age、m_score 是私有成员变量,不能在类外部通过对象访问。如下定义就是一种错误的表示:
Student stu;stu.m_name = "小明";stu.m_age = 15;stu.m_score = 92.5f;stu.show();
这种将成员变量声明为 private、将部分成员函数声明为 public 的做法体现了类的封装性。所谓封装,是指尽量隐藏类的内部实现,只向用户提供有用的成员函数。private 关键字的作用在于更好地隐藏类的内部实现,该向外暴露的接口(能通过对象访问的成员)都声明为 public,不希望外部知道、或者只在类内部使用的、或者对外部没有影响的成员,都建议声明为 private。
根据C++软件设计规范,实际项目开发中的成员变量以及只在类内部使用的成员函数(只被成员函数调用的成员函数)都建议声明为 private,而只将允许通过对象调用的成员函数声明为 public。另外还有一个关键字 protected,声明为 protected 的成员在类外也不能通过对象访问,但是在它的派生类内部可以访问。
声明为 private 的成员和声明为 public 的成员的次序可以是任意的,既可以先出现 private 部分,也可以先出现 public 部分。如果既不写 private 也不写 public,默认为 private。在一个类体中,private 和 public 可以分别出现多次。但是为了使程序清晰,应该养成使每一种成员访问限定符在类定义体中只出现一次的习惯。
类的构造函数:
在C++中,有一种特殊的成员函数,它的名字和类名相同,没有返回值,不需要用户显式调用(用户也不能调用),而是在创建对象时自动执行。这种特殊的成员函数就是构造函数。实例3中,通过成员函数 setname()、setage()、setscore() 分别为成员变量 name、age、score 赋值,这样做虽然有效,但显得有点麻烦。有了构造函数,我们就可以简化这项工作,在创建对象的同时为成员变量赋值。见实例4:#include <iostream>using namespace std;class Student{private:char *m_name;int m_age;float m_score;public://声明构造函数Student(char *name, int age, float score);//声明普通成员函数void show();};//定义构造函数Student::Student(char *name, int age, float score){m_name = name;m_age = age;m_score = score;}//定义普通成员函数void Student::show(){cout << m_name << "的年龄是" << m_age << ",成绩是" << m_score << endl;}int main(){//创建对象时向构造函数传参Student stu("小明", 15, 92.5f);stu.show();//创建对象时向构造函数传参Student *pstu = new Student("小红", 16, 96);pstu->show();return 0;}
实例4,在 Student 类中定义了一个构造函数Student(char *, int, float),它的作用是给三个 private 属性的成员变量赋值。要想调用该构造函数,就得在创建对象的同时传递实参,并且实参由( )包围,和普通的函数调用非常类似。在栈上创建对象时,实参位于对象名后面,例如Student stu("小明", 15, 92.5f);在堆上创建对象时,实参位于类名后面,例如new Student("小红", 16, 96)。
构造函数必须是 public 属性的,否则创建对象时无法调用。设置为 private、protected 属性不会报错,但没有意义。构造函数没有返回值,因为没有变量来接收返回值,即使有也毫无用处,这意味着:(1)不管是声明还是定义,函数名前面都不能出现返回值类型,即使是 void 也不允许;(2)函数体中不能有 return 语句。
构造函数的调用是强制性的,一旦在类中定义了构造函数,那么创建对象时就一定要调用,不调用是错误的。如果有多个重载的构造函数,那么创建对象时提供的实参必须和其中的一个构造函数匹配;反过来说,创建对象时只有一个构造函数会被调用。
实例4中的代码,如果写作Student stu或者new Student就是错误的,因为类中包含了构造函数,而创建对象时却没有调用。
如果用户没有定义构造函数,那么编译器会自动生成一个默认的构造函数,只是这个构造函数的函数体是空的,没有形参,也不执行任何操作。比如上面的 Student 类,默认生成的构造函数如下:Student(){}。
一个类必须有构造函数,要么用户自己定义,要么编译器自动生成。一旦用户自己定义了构造函数,不管有几个,也不管形参如何,编译器都不再自动生成。和普通成员函数一样,构造函数是允许重载的。一个类可以有多个重载的构造函数,创建对象时根据传递的实参来判断调用哪一个构造函数。
#include <iostream>using namespace std;class Student{private:char *m_name;int m_age;float m_score;public:Student();Student(char *name, int age, float score);void setname(char *name);void setage(int age);void setscore(float score);void show();};Student::Student(){m_name = NULL;m_age = 0;m_score = 0.0;}Student::Student(char *name, int age, float score){m_name = name;m_age = age;m_score = score;}void Student::setname(char *name){m_name = name;}void Student::setage(int age){m_age = age;}void Student::setscore(float score){m_score = score;}void Student::show(){if (m_name == NULL || m_age <= 0){cout << "成员变量还未初始化" << endl;}else{cout << m_name << "的年龄是" << m_age << ",成绩是" << m_score << endl;}}int main(){//调用构造函数 Student(char *, int, float)Student stu("小明", 15, 92.5f);stu.show();//调用构造函数 Student()Student *pstu = new Student();pstu->show();pstu->setname("小红");pstu->setage(16);pstu->setscore(96);pstu->show();return 0;}
类的拷贝构造函数:
拷贝构造函数是一种特殊的构造函数,函数的名称必须和类名称一致,它唯一的一个参数是本类型的一个引用变量,该参数是const类型,不可变的。例如:类X的拷贝构造函数的形式为X(X& x)。#include <iostream> using namespace std;class CExample {private:int a;public://构造函数 CExample(int b){a = b;}//拷贝构造函数 CExample(const CExample& C){a = C.a;}//一般函数 void Show(){cout << "a的值为:"<<a<< endl;}};int main(){CExample A(10);CExample B = A; // CExample B(A); 也是一样的 B.Show();return 0;}
上面的例子中,CExample(const CExample& C)就是自定义的拷贝构造函数。拷贝分为浅拷贝和深拷贝两种,浅拷贝,指的是在对象复制时,只对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了,但是一旦对象存在了动态成员,那么浅拷贝就会出问题了。在某些状况下,类内成员变量需要动态开辟堆内存,如果实行浅拷贝,即把对象里的值完全复制给另一个对象,如A=B。这时,如果B中有一个成员变量指针已经申请了内存,那A中的那个成员变量也指向同一块内存。这就出现了问题:当B把内存释放了(如:析构),这时A内的指针就是野指针了,出现运行错误。举个错误的例子:
class Rect { public: Rect()// 构造函数,p指向堆中分配的一空间 { p = new int(100); } ~Rect()// 析构函数,释放动态分配的空间 { if(p != NULL) { delete p; } } private: int width; int height; int *p;// 一指针成员 }; int main() { Rect rect1; Rect rect2(rect1); // 复制对象 return 0; }
上面例子中,执行的是浅拷贝:
我们需要的不是两个p有相同的值,而是两个p指向的空间有相同的值,解决办法就是使用“深拷贝”。深拷贝是指:如果一个类拥有资源,当这个类的对象发生复制过程的时候,资源重新分配,这个过程就是深拷贝。正确的例子为:
class Rect { public: Rect()// 构造函数,p指向堆中分配的一空间 { p = new int(100); } Rect(const Rect& r) { width = r.width; height = r.height; p = new int; // 为新对象重新动态分配空间 *p = *(r.p); } ~Rect()// 析构函数,释放动态分配的空间 { if(p != NULL) { delete p; } } private: int width; int height; int *p;// 一指针成员 };
此时rect1的p和rect2的p各自指向一段内存空间,但它们指向的空间具有相同的内容,这就是所谓的“深拷贝”。
类的析构函数(Destructor)
析构函数(destructor) 与构造函数相反,当对象结束其生命周期时(例如对象所在的函数已调用完毕),系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作(例如在建立对象时用new开辟了一片内存空间,应在退出前在析构函数中用delete释放)。触发条件:当对象被销毁时,会自动调用析构函数,释放资源。构造函数在对象实例化时自动调用,析构函数在对象销毁时自动调用。
析构函数(Destructor)也是一种特殊的成员函数,没有返回值,不需要程序员显式调用(程序员也没法显式调用),而是在销毁对象时自动执行。构造函数的名字和类名相同,而析构函数的名字是在类名前面加一个“~”符号。析构函数没有参数,不能被重载,因此一个类只能有一个析构函数。如果用户没有定义,编译器会自动生成一个默认的析构函数。
#include <string.h>#include <iostream>using namespace std;class stud{private://私有部分int num;char name[10];char sex;public://公用部分stud(int n, const char nam[], char s)//构造函数{num = n;strcpy_s(name, nam);sex = s;}~stud() //析构函数{cout << "stud has been destructed!" << endl;//通过输出提示告诉我们析构函数确实被调用了}void display()//成员函数,输出对象的数据{cout << "num:" << num << endl;cout << "name:" << name << endl;cout << "sex:" << sex << endl;}};int main(){stud stud1(10010, "Wangli", 'f'), stud2(10011, "Zhangfun", 'm');//建立两个对象stud1.display();//输出学生1的数据stud2.display();//输出学生2的数据return 0;}//主函数结束的同时,对象stud1,stud2均应被“清理”,而清理就是通过调用了析构函数实现的。
参考:
/mr-wid/archive//02/18/2916309.html
/cpp/biancheng/view/185.html
/lwbeyond/article/details/656/
/link?url=R4MhPpouXzfx9uUINgnUeSnWDzQCEnzLFwy41wmqEjiasMGrxXXI2Ogk6rAcSnpSlCEw_MvLPhQ90NhAXvk23CM2sntilP9UufOMzZ-8bPgqP-XMqrTSDhhCS_92qGu0
/qq_34803572/article/details/55213551