-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删.
第一:
C++ 中的对象组合
C++ 中的类可以使用其它类定义成员变量
class M
{
private:
int mI;
public:
M(int i)
{
printf("M(int i), i = %d\n", i);
mI = i;
}
int getI()
{
return mI;
}
};
class Test
{
private:
const int c;
M m1;
M m2;
public:
//对成员变量进行初始化
Test() : c(1), m2(3), m1(2)
{
printf("Test()\n");
}
};
int main()
{
Test t1;
Test t2 = Test();
return 0;
}
C++ 中提供了 初始化列表 对成员变量进行初始化
语法规则
Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)
{
// some other assignment operation
}
注意:
成员变量的初始化顺序与声明的顺序相关,与在初始化列表中的顺序无关
初始化列表先于构造函数的函数体执行
#include <stdio.h>
class M
{
private:
int mI;
public:
M(int i)
{
printf("M(int i), i = %d\n", i);
mI = i;
}
int getI()
{
return mI;
}
};
class Test
{
private:
//成员变量声明顺序
const int c;//初始化时编译器得不到c的值,则c是只读变量
M m1;
M m2;
public:
//const变量可以被初始化,但是不能被赋值
Test() : c(1), m2(3), m1(2)//初始化列表顺序
{
printf("Test()\n");
}
void print()
{
printf("c = %d, m1.mI = %d, m2.mI = %d\n", c, m1.getI(), m2.getI());
}
};
void run()
{
Test t1;
t1.print();
}
int main()
{
run();
printf("Press any key to continue...");
getchar();
return 0;
}
第二:
小插曲
类中的const 成员是肯定会被分配空间的
类中的const 成员变量只是一个只读变量
编译器无法直接得到 const 成员变量的初始值,因此无法进入符号表成为真正意义上的常量
初始化与赋值不同
初始化是用已存在的对象或值对 正在创建的对象 进行初值设置
赋值是用已存在的对象或值对 已经存在的对象 进行值设置
区别:
初始化:被初始化的对象正在创建
赋值:被赋值的对象已经存在
第三:
对象的销毁
生活中存在的对象都是被初始化后才上市的
生活中的对象被销毁前会做一些清理工作
一般而言所有被销毁的对象都需要做清理
解决方案
为每个类都提供一个 public 的 destroy 函数
对象不再被需要时立即调用 destroy函数进行清理
destroy 只是一个普通的函数,必须显示的调用
如果对象销毁前没有做清理,那么很可能造成资源泄漏
在构造函数中申请的资源,需要在对象销毁前释放
第四:
C++ 中的析构函数
C++ 中的类可以定义一个特殊的成员函数清理对象
这个特殊的成员函数叫做析构函数
定义:~ClassName()
析构函数没有参数也没有任何返回类型的声明
析构函数在对象销毁时自动被调用
#include <stdio.h>
class Test
{
private:
int mI;
public:
Test(int i) : mI(i)
{
printf("Test(), mI = %d\n", mI);
}
~Test()//析构函数
{
printf("~Test(), mI = %d\n", mI);
}
};
void run()
{
//自动调用构造函数
Test t1(1);
Test t2(2);
//自动调用析构函数
}
int main()
{
run();
printf("Press any key to continue...");
getchar();
return 0;
}
第五:
Array 类的进化
#ifndef _ARRAY_H_
#define _ARRAY_H_
class Array
{
private:
int mLength;
int* mSpace;
public:
Array(int length);
Array(const Array& obj);
int length();
void setData(int index, int value);
int getData(int index);
~Array();//改成析构函数
};
#endif
#include "Array.h"
Array::Array(int length)
{
if( length < 0 )
{
length = 0;
}
mLength = length;
mSpace = new int[mLength];
}
Array::Array(const Array& obj)
{
mLength = obj.mLength;
mSpace = new int[mLength];
for(int i=0; i<mLength; i++)
{
mSpace[i] = obj.mSpace[i];
}
}
int Array::length()
{
return mLength;
}
void Array::setData(int index, int value)
{
mSpace[index] = value;
}
int Array::getData(int index)
{
return mSpace[index];
}
Array::~Array()//修改成析构函数
{
mLength = -1;
delete[] mSpace;
}
#include <stdio.h>
#include "Array.h"
int main()
{
Array a1(10);
for(int i=0; i<a1.length(); i++)
{
a1.setData(i, i);
}
for(int i=0; i<a1.length(); i++)
{
printf("Element %d: %d\n", i, a1.getData(i));
}
Array a2 = a1;
for(int i=0; i<a2.length(); i++)
{
printf("Element %d: %d\n", i, a2.getData(i));
}
// a1.destory();
// a2.destory();
printf("Press any key to continue...");
getchar();
return 0;
}
第六:
构造与析构
构造函数与析构函数的调用秩序
当类中有成员变量是其它类的对象时
首先调用成员变量的构造函数
调用顺序与声明顺序相同
之后调用自身类的构造函数
析构函数的调用秩序与对应的构造函数调用秩序相反
第七:
构造与析构的调用秩序
#include <stdio.h>
class Test//定义Test类
{
private:
int mI;
public:
/无参构造函数
Test()
{
printf("Test()\n");
mI = -1;
}
//整型构造函数
Test(int i)
{
printf("Test(int i), i = %d\n", i);
mI = i;
}
//拷贝构造函数
Test(const Test& obj)
{
printf("Test(const Test& obj), i = %d\n", obj.mI);
mI = obj.mI;
}
~Test()
{
printf("~Test(), i = %d\n", mI);
}
};
void func(Test t)
{
Test r(1);// Test(int i)
}
void run()
{
Test t(0);// Test(int i)
func(t);//func(Test t) 实参初始化形参 --> Test(const Test& obj)
}
int main()
{
run();
printf("Press any key to continue...");
getchar();
return 0;
}
第八:
可以直接调用构造函数吗?
如果可以,直接调用构造函数会有什么情况发生呢?
可以直接调用构造函数,直接调用构造函数将得到一个临时对象。
不要在构造函数里面调用构造函数!!!
#include <stdio.h>
class Test
{
private:
int mI;
int mJ;
const char* mS;//字符指针
public:
//构造函数
Test()
{
printf("Test()\n");
//将mI mJ 赋值为0
mI = 0;
mJ = 0;
}
//构造函数
Test(const char* s)
{
printf("Test(const char* s)\n");
//直接调用构造函数,直接调用构造函数将得到一个临时对象,这一行执行完后临时对象立即被销毁,mI mJ 不会赋值为0
Test();//调用上面的Test函数,这里没有起作用!!!!
mS = s;
}
~Test()
{
printf("~Test()\n");
}
void print()
{
printf("mI = %d, mJ = %d, mS = %s\n", mI, mJ, mS);
}
};
void run()
{
Test t = Test("Delphi Tang"); //等价 Test t("Delphi Tang");
t.print();
}
int main()
{
run();
printf("Press any key to continue...");
getchar();
return 0;
}
小结
析构函数是 C++ 中对象销毁时做清理工作的特殊函数
析构函数在对象销毁时自动被调用
析构函数是对象所使用的资源及时释放的保障
析构函数的调用秩序与构造函数相反