我们先从一个题来开始：这是改正之后的样子。
#include <iostream>
using namespace std;
class MyClass
{
public:
MyClass(int x):number(x) {}
// ERROR **********found**********
~MyClass() {} //~MyClass(int x) {}
// ERROR **********found**********
friend void Judge(MyClass &obj); // void Judge(MyClass &obj);
private:
int number;
};
void Judge(MyClass &obj)
{
if(obj.number==10)
cout<<"You are right."<<endl;
else
cout<<"Sorry"<<endl;
}
int main()
{
// ERROR **********found**********
MyClass object(10); // MyClass object();
Judge(object);
return 0;
}
//下面的是改正过的，//后面是其错误的形式。这个题就涉及到了构造函数、析构函数以及友元函数，我们来仔细的介绍一下吧。
Ø 构造函数
u 定义
构造函数 ，是一种特殊的方法 。主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中 。特别的一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们即构造函数的重载。
构造函数是与类名相同的，在建立对象时自动调用的函数，如果在定义类时，没有为类定义构造函数，编译系统就生成一个默认形式的隐含的构造函数，这个构造函数的函数体是空的，因此默认构造函数不具备任何功能。
u 构造函数的作用
class Counter
{
public:
// 类Counter的构造函数
// 特点：以类名作为函数名，无返回类型
Counter()
{
m_value = 0;
}
private:
// 数据成员
int m_value;
}
eg: Counter c1;
编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter()自动地初始化对象c1的m_value值设置为0
故：
构造函数的作用：初始化对象的数据成员。在此需要注意的是私有成员只能声明不能初始化,并且只有通过构造函数或者成员函数来初始化。
u 构造函数种类
class Complex
{
private :
double m_real;
double m_imag;
public:
// 无参数构造函数
// 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
// 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
Complex(void)
{
m_real = 0.0;
m_imag = 0.0;
}
// 一般构造函数（也称重载构造函数）
// 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
// 例如：你还可以写一个 Complex( int num)的构造函数出来
// 创建对象时根据传入的参数不同调用不同的构造函数
Complex(double real, double imag)
{
m_real = real;
m_imag = imag;
}
// 复制构造函数（也称为拷贝构造函数）
// 复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
// 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述
Complex(const Complex & c)
{
// 将对象c中的数据成员值复制过来
m_real = c.m_real;
m_img = c.m_img;
}
// 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
// 例如：下面将根据一个double类型的对象创建了一个Complex对象
Complex::Complex(double r)
{
m_real = r;
m_imag = 0.0;
}
// 等号运算符重载
// 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
// 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
Complex &operator=( const Complex &rhs )
{
// 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
if ( this == &rhs )
{
return *this;
}
// 复制等号右边的成员到左边的对象中
this->m_real = rhs.m_real;
this->m_imag = rhs.m_imag;
// 把等号左边的对象再次传出
// 目的是为了支持连等 eg: a=b=c 系统首先运行 b=c
// 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
return *this;
}
};
下面使用上面定义的类对象来说明各个构造函数的用法：
void main()
{
// 调用了无参构造函数，数据成员初值被赋为0.0
Complex c1，c2;
// 调用一般构造函数，数据成员初值被赋为指定值
Complex c3(1.0,2.5);
// 也可以使用下面的形式
Complex c3 = Complex(1.0,2.5);
// 把c3的数据成员的值赋值给c1
// 由于c1已经事先被创建，故此处不会调用任何构造函数
// 只会调用 = 号运算符重载函数
c1 = c3;
// 调用类型转换构造函数
// 系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
c2 = 5.2;
// 调用拷贝构造函数( 有下面两种调用方式)
Complex c5(c2);
Complex c4 = c2; // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
}
讲了以上这些，是不是有一定的理解了。
Ø 析构函数
本篇开头那个题里就出现一个错误，那就是析构函数是没有形参的。
u 定义
析构函数也称之为拆构函数，是在对象消失之前的瞬间自动调用的函数，其形式为：
~构造函数（）
u 特点
1. 固定的函数名称
~类名( )
2. 没有返回类型
3. 没有参数
4. 不可以重载
5. 一般由系统自动的调用
u 举例
当用户没有显式定义析构函数时, 编译器同样会为对象生成一个默认的析构函数, 但默认生成的析构函数只能释放类的普通数据成员所占用的空间, 无法释放通过 new 或 malloc 进行申请的空间, 因此有时我们需要自己显式的定义析构函数对这些申请的空间进行释放, 避免造成内存泄露。
1 #include <iostream>
2 #include <cstring>
3 using namespace std;
4 class Book
5{
6 public:
7 Book( const char *name ) //构造函数
8 {
9 bookName = new char[strlen(name)+1];
10 strcpy(bookName, name);
11 }
12 ~Book() //析构函数
13 {
14 cout<<"析构函数被调用...\n";
15 delete []bookName; //释放通过new申请的空间
16 }
17 void showName() { cout<<"Book name: "<< bookName <<endl; }
18
19 private:
20 char *bookName;
21 };
22
23 int main()
24 {
25 Book CPP("C++ Primer");
26 CPP.showName();
27
28 return 0;
29
30 }
代码说明:
代码中创建了一个 Book 类, 类的数据成员只有一个字符指针型的 bookName, 在创建对象时系统会为该指针变量分配它所需内存, 但是此时该指针并没有被初始化所以不会再为其分配其他多余的内存单元。在构造函数中, 我们使用 new 申请了一块 strlen(name)+1 大小的空间, 也就是比传入进来的字符串长度多1的空间, 目的是让字符指针 bookName 指向它, 这样才能正常保存传入的字符串。
在 main 函数中使用 Book 类创建了一个对象 CPP, 初始化 bookName 属性为 "C++ Primer"。从运行结果可以看到, 析构函数被调用了, 这时使用 new 所申请的空间就会被正常释放。
自然状态下对象何时将被销毁取决于对象的生存周期, 例如全局对象是在程序运行结束时被销毁, 自动对象是在离开其作用域时被销毁。
Ø 友元函数
声明： friend + 普通函数声明
声明： friend + 普通函数声明
实现位置：可以在类外或类中
实现代码：与普通函数相同
调用：类似普通函数，直接调用
u 定义
友元是一种定义在类外部的普通函数，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率，但是，它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。
实现位置：可以在类外或类中
实现代码：与普通函数相同
调用：类似普通函数，直接调用
u 定义
友元是一种定义在类外部的普通函数，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率，但是，它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。
u 举例
#include
class Point
{
public:
Point(double xx, double yy) { x=xx; y=yy; }
void Getxy();
friend double Distance(Point &a, Point &b);
private:
double x, y;
};
void Point::Getxy()
{
cout<<"("<<<","<<Y<<")"<<ENDL;< FONT>
}
double Distance(Point &a, Point &b)
{
double dx = a.x - b.x;
double dy = a.y - b.y;
return sqrt(dx*dx+dy*dy);
}
void main()
{
Point p1(3.0, 4.0), p2(6.0, 8.0);
p1.Getxy();
p2.Getxy();
double d = Distance(p1, p2);
cout<<"Distance is"<<
FONT>
}
说明：在该程序中的Point类中说明了一个友元函数Distance()，它在说明时前边加friend关键字，标识它不是成员函数，而是友元函数。它的定义方法与普通函数定义一样，而不同于成员函数的定义，因为它不需要指出所属的类。但是，它可以引用类中的私有成员，函数体中 a.x，b.x，a.y，b.y都是类的私有成员，它们是通过对象引用的。在调用友元函数时，也是同普通函数的调用一样，不要像成员函数那样调用。
本例中，p1.Getxy()和p2.Getxy()这是成员函数的调用，要用对象来表示。而Distance(p1,p2)是友元函数的调用，它直接调用，不需要对象表示，它的参数是对象。
那么我们再对于开头那个题的理解是不是进一步加深了呢~
扫一扫
2095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
