带有参数的构造函数(可以使每个对象有不同的初始化状态)
构造函数可以根据需要定义参数
一个类中可以存在多个重载的构造函数
构造函数的重载遵循C++重载的规则
class Test
{
public:
Test(int v)
{
//use v to initialize member
}
}
友情提示
对象定义和对象声明不同
对象定义——申请对象的空间并调用构造函数
对象声明——告诉编译器存在这样一个对象
Test t; //定义对象并调用构造函数
int main()
{
//告诉编译器存在名为t 的Test对象
extern Test t;
return 0;
}
构造函数的自动调用
class Test
{
public:
Test() { }
Test(int v) { }
};
int main
{
Test t; //调用Test()
Test t1(1); //调用Test(int v)
Test t2 = 1; //调用Test(int v)
return 0;
}
Test t1(1)解析：
定义一个Test 对象，名字为t1。圆括号里面有个立即数1，看上去很像函数调用。其实它用来告诉编译器
要调用带有参数的构造函数，调用哪个带有参数的构造函数呢？这时候就需要利用重载的规则了。
立即数1的类型为int，所以就告诉编译器所要调用的构造函数，它只有一个参数，并且参数的类型为int.在这个地方就是Test(int v)
1 #include <stdio.h>
2
3 class Test
4 {
5 public:
6 Test()
7 {
8 printf("Test()
");
9 }
10 Test(int v)
11 {
12 printf("Test(int v), v = %d
", v);
13 }
14 };
15
16 int main()
17 {
18 Test t; // 调用 Test()
19 Test t1(1); // 调用 Test(int v)
20 Test t2 = 2; // 调用 Test(int v)
21
22 int i(100); //用100来初始化i。相当于int i =100;
23
24 printf("i = %d
", i);
25
26 return 0;
27 }
注意：
Test t2 = 2; //用2来初始化t2
int i = 1; //用1对变量就进行初始化
i = 2; //用2对变量i进行赋值
以前在学习C语言时，初始化和赋值好像没有什么差别，于是就将赋值和初始化混淆了。
在C语言中，两者貌似差距很小。但是在C++中，两者之间的差异很大。原因是初始化会调用构造函数。
一定要记住，初始化会调用构造函数，赋值时调用的就不是构造函数了。赋值的时候究竟发生了什么？以后再说。
构造函数的调用
-一般情况下，构造函数在对象定义时被自动调用
-一些特殊情况下，需要手工调用构造函数
如何创建一个对象数组？
编程实验：构造函数的手动调用
1 #include <stdio.h>
2
3 class Test
4 {
5 private:
6 int m_value;
7 public:
8 Test()
9 {
10 printf("Test()
");
11
12 m_value = 0;
13 }
14 Test(int v)
15 {
16 printf("Test(int v), v = %d
", v);
17
18 m_value = v;
19 }
20 int getValue()
21 {
22 return m_value;
23 }
24 };
25
26 int main()
27 {
28 Test ta[3] = {Test(), Test(1), Test(2)};
29
30 for(int i=0; i<3; i++)
31 {
32 printf("ta[%d].getValue() = %d
", i , ta[i].getValue());
33 }
34
35 Test t = Test(100);
36
37 printf("t.getValue() = %d
", t.getValue());
38
39 return 0;
40 }
需求：开发一个数组类解决原生数组的安全性问题
-提供函数获取数组长度
-提供函数获取数组元素
-提供函数设置数组元素
IntArray.h
1 #ifndef _INTARRAY_H_
2 #define _INTARRAY_H_
3
4 class IntArray
5 {
6 private:
7 int m_length;
8 int* m_pointer;
9 public:
10 IntArray(int len);
11 int length();
12 bool get(int index, int& value);
13 bool set(int index ,int value);
14 void free();
15 };
16
17 #endif
IntArray.cpp
1 #include "IntArray.h"
2
3 IntArray::IntArray(int len)
4 {
5 m_pointer = new int[len];
6
7 for(int i=0; i<len; i++)
8 {
9 m_pointer[i] = 0;
10 }
11
12 m_length = len;
13 }
14
15 int IntArray::length()
16 {
17 return m_length;
18 }
19
20 bool IntArray::get(int index, int& value)
21 {
22 bool ret = (0 <= index) && (index < length());
23
24 if( ret )
25 {
26 value = m_pointer[index];
27 }
28
29 return ret;
30 }
31
32 bool IntArray::set(int index, int value)
33 {
34 bool ret = (0 <= index) && (index < length());
35
36 if( ret )
37 {
38 m_pointer[index] = value;
39 }
40
41 return ret;
42 }
43
44 void IntArray::free()
45 {
46 delete[]m_pointer;
47 }
main.cpp
#include <stdio.h>
#include "IntArray.h"
int main()
{
IntArray a(5);
for(int i=0; i<a.length(); i++)
{
a.set(i, i + 1);
}
for(int i=0; i<a.length(); i++)
{
int value = 0;
if( a.get(i, value) )
{
printf("a[%d] = %d
", i, value);
}
}
a.free();
return 0;
}
小结：
构造函数可以根据需要定义参数
构造函数之间可以存在重载关系
构造函数遵循C++中重载函数的规则
对象定义时会触发构造函数的调用
在一些情况下可以手动调用构造函数