浅谈类的六个默认的成员函数
类的定义和使用,C++,类的六个默认的成员函数2016-08-09
面向对象程序设计:
相信大家都明白C++是面向对象的语言(C++不是纯的面向对象的语言，是基于面向对象的语言(C++包含面向过程的语言C语言))，那仫什仫是面向对象呢？
要理解面向对象首先就要理解什仫是对象.
对象：在现实世界中任何事物都是对象，它可以是具体的，有形的，也可以是无形的，抽象的， 比如香蕉，橘子，苹果，卡车，汽车...这些具体的事物，再比如一场比赛，一场电影...这些抽象的事物，地球上的万事万物都可以是对象而我们把具有相同属性的对象统称为类(类是对象的抽象，对象是类的实例)
看到这里我们大概对什仫是类有了更加深入的理解，那仫在C++中的类是什仫样子呢？它有什仫规律呢？
在C++中类和对象的定义和使用范例：
下面我们先来看一个关于日期类的功能实现代码：
#include<iostream>
using namespace std;
class Data
{
public:
//Data(); //不带参的构造函数
Data(int y=2017,int m=1,int d=1); //带参的构造函数
void print();
private:
int year;
int month;
int day;
};
Data::Data(int y,int m,int d) //全缺省
{
year=y;
month=m;
day=d;
}
void Data::print()
{
cout<<year<<"-"<<month<<"-"<<day<<endl;
}
int main()
{
Data d1;
Data d2(2016,7,3);
d1.print();
d2.print();
return 0;
}
类的构成：数据成员，成员函数
1.类的定义与结构体类似，不同之处在于：如果结构体和类都没有限定符，结构体中默认是公有的(public),类中默认是私有的(private)
2.可以在类内定义成员函数也可以在类外定义成员函数，比如上述代码就是在类外定义成员函数的
类的访问限定符：public,private,protected
1.public可以从类外部直接访问，private/protected不能从类外部直接访问
2.每个限定符在一个类中可以使用多次，它的作用域从该限定符出现到下一个限定符之前或类体结束前
3.类的访问权限体现了类的封装性
4.protected:称为类的保护部分，用它来修饰的话：成员可以由该类和该类的派生类的成员函数来访问，类外是无法访问的(此限定符到学到继承时再详细理解)
类的作用域
在C++的作用域分类中，除了C和C++共有的局部域和全局域之外还有C++特有的类域和名字空间域:
类域(类的作用域)
1.在类外定义成员需要使用::(作用域解析符)来指明属于哪一个类
2.访问方式与结构体类似,对象可以通过.直接访问数据成员，指向对象的指针可以通过->来访问类中的成员
3.类的成员都在类的作用域内，成员函数可任意访问成员变量和其他成员函数
隐含的this指针
1.this指针是成员函数的隐含指针形参，我们不能在成员函数的形参中添加this指针的参数定义，也不能在调用时显示this指针
2.在对象调用成员函数时，对象地址作为实参传递给成员函数的第一个指针形参this指针
3.每个成员函数都有一个指针形参，是隐含的(构造函数比较特殊没有这个隐含的this指针)
在上述代码中调用print函数时就传过来的是隐含的this指针，具体分析见下图:
类的六个默认的成员函数：构造函数，拷贝构造函数，析构函数，赋值操作符重载，取地址操作符重载，const修饰的取地址操作符重载
构造函数
在上述Data类中有两个函数Data(int y,int m,int d);和Data(),这两个函数就是构造函数(用于给类的数据成员初始化)
构造函数的特点：(构造函数就是特殊的成员函数)
1.函数名与类名相同
2.构造函数是没有返回值也没有类型的，在定义构造函数时，是不能说明构造函数的类型的，甚至定义为void也不行，没有类型不等于类型为空.
3.如果类中没有定义构造函数，则C++编译器会自动产生一个缺省的构造函数，如果定义了就使用这个定义的构造函数
4.构造函数可以重载,比如在上述代码中定义了两个构造函数Data
5.构造函数也和普通的成员函数类似，即可以在类内定义也可以在类外定义
6.对象实例化时自动调用对应的构造函数
7.无参的构造函数和全缺省的构造函数都是缺省的构造函数，并且缺省的构造函数只能有一个；
在上述代码中如果在带参数的构造函数的声明中使用全缺省的定义方式时编译器会报错,因为如果你给类实例化时是如果是不带参的而且构造函数是可以重载的，此时会产生调用不明确的情况
8.构造函数不存在隐含的this指针.因为构造函数是给数据成员初始化的此时还未初始化所以不存在隐含的this指针
构造函数的两种初始化方式：
1).构造函数体内进行复制
2).初始化列表的方式 (高效)
初始化列表是以一个冒号开始，接着一个逗号分隔数据列表，且每个数据成员都放在一个括号中进行初始化
必须放在初始化列表中的成员变量：
1).常量成员变量(const 修饰变量时在C++中该变量具有常性：一经初始化就不可再修改了，所以const修饰的成员变量中必须放在初始化列表中初始化)
2).引用类型成员变量
3).没有缺省构造函数的类成员(在日期类和时间类中，要输出日期和时间就得在日期类中拷贝构造时间类的对象，如果这个时间类是没有默认的构造函数则必须放在日期类的初始化列表中初始化)
拷贝构造函数
定义：创建对象时使用同类对象来初始化
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Student
{
public:
Student(char *name,int age)
{
_name = (char *)malloc(sizeof(char)*(strlen(name)+1)); //多一个位置存\0
if (NULL == _name)
{
cout << "out of memory" << endl;
exit(EXIT_FAILURE);
}
strcpy(_name,name);
_age = age;
}
~Student()
{
free(_name);
_name = 0;
}
private:
char *_name;
int _age;
};
int main()
{
Student s1("zhangsan",20);
Student p2= s1;
system("pause");
return 0;
} Student(const Student &s)
{
_name = new char[strlen(s._name)+1];
if (_name != 0)
{
strcpy(_name,s._name);
_age = s._age;
}
}析构函数
析构函数：是一种特殊的成员函数，通常用于回收或者清理资源，它的特点如下：
1.析构函数在类名上加上字符~
2.析构函数无参数也无返回值，类似构造函数
3.唯一性：一个类有且只有一个析构函数(不可重载)
4.析构函数不是删除对象而是清理
5.当程序执行到return 0;快要结束时系统自动调用析构函数
必须用户自定义的析构函数：在构造函数中分配空间的情况必须用户自定义析构函数
运算符重载(赋值操作符重载，取地址操作符重载，const修饰的取地址操作符重载...)
为了支持程序的可读性，C++支持运算符重载，那仫什仫是运算符重载的特点呢？下面让我们先来看一道简单的运算符重载的例子(它的作用是将简单的加法运算输出结果两个数为相减的结果):
#include<iostream>
using namespace std;
class Int
{
public:
Int(int d=0) //全缺省的构造函数
{
_data = d;
}
Int operator+(Int m)
{
return Int(_data - m._data);
}
public:
int _data;
};
int main()
{
Int a(3);
Int b(5);
Int c = a+b;
cout<<c._data<<endl;
return 0;
}
由上述代码总结出以下运算符重载的特征：
1.赋值运算符的重载是对一个已经存在的对象进行赋值
2.运算符重载不改变运算符的优先级/结合性/操作符个数
3.几个C++不能重载的运算符： .* (点乘) / ::(作用域解析符) / sizeof / ?:(条件运算符) / .
什仫是点乘？它是如何使用的？请看下面一个简单的使用范例：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class A
{
public:
void print()
{
cout<<"hehe"<<endl;
}
};
void (A::*pfun)()=&A::print; //函数指针
int main()
{
A a;
a.print(); //hehe
(a.*pfun)();//hehe
system("pause");
return 0;
}