标签：就会 pre 构造 类的构造函数 个数 创建 define 对象数组 c++
在类里面成员函数的初始值是多少了？（取决于创建对象的位置，是在堆、栈、还是在静态存储区中创建。）
例如：
#include <stdio.h> class Test { private: int i; int j; public : int get_i(void) {return i;} int get_j(void) {return j;} }; Test Ta;//在静态存储区中定义 Test类 int main(int argc, char *argv[]) { printf("Ta.i = %d\n",Ta.get_i());//Ta.i = 0 printf("Ta.j = %d\n",Ta.get_j());//Ta.j = 0 Test Tb;//在栈上定义类 printf("Tb.i = %d\n",Tb.get_i());//Tb.i = 随机数 printf("Tb.j = %d\n",Tb.get_j());//Tb.j = 随机数 Test *Tc = new Test;//在堆上定义类 printf("Tc->i = %d\n",Tc->get_i());//Tc.i = 随机数 printf("Tc->j = %d\n",Tc->get_j());//Tc.i = 随机数 return 0; }
运行结果：
Ta.i = 0 Ta.j = 0 Tb.i = 1808322352 Tb.j = 32766 Tc->i = 0 Tc->j = 0
可以看出，对象只是变量，所以在不同的地方定义变量，所的到的初始值也不同。
在堆上定义：为随机数
在栈上定义：为随机数
在静态存储区上定义：因为静态存储区中变量默认为0 ，所以为0
这样在不同地方定义初始值就会不同，这样是不允许的所以我们需要对变量进行初始化。这就引入了类的构造函数。
构造函数：
构造函数特点：
1、构造函数没有任何返回类型的声明。
2、构造函数在定义的时候被自动调用。
例如：
#include <stdio.h> class Test { private: int i; int j; public : int get_i(void) {return i;} int get_j(void) {return j;} Test() { printf("Test()\n"); i = 5; j = 10; } }; Test Ta; int main(int argc, char *argv[]) { printf("Ta.i = %d\n",Ta.get_i()); printf("Ta.j = %d\n",Ta.get_j()); Test Tb; printf("Tb.i = %d\n",Tb.get_i()); printf("Tb.j = %d\n",Tb.get_j()); Test *Tc = new Test; printf("Tc->i = %d\n",Tc->get_i()); printf("Tc->j = %d\n",Tc->get_j()); return 0; }
在类中加入构造函数。
运行结果：
Test() Ta.i = 5 Ta.j = 10 Test() Tb.i = 5 Tb.j = 10 Test() Tc->i = 5 Tc->j = 10
可以看出每次定义都调用了一次构造函数。
一个类中可以有多个构造函数构成重载，重载的概念在类中同样适用。
例如：
#include <stdio.h> class Test { private: int i; int j; public : int get_i(void) {return i;} int get_j(void) {return j;} Test() { printf("Test()\n"); i = 5; j = 10; } Test(int v) { printf("Test(int v);v = %d\n",v); i = 20; j = 30; } }; int main(int argc, char *argv[]) { Test Ta; printf("Ta.i = %d\n",Ta.get_i()); printf("Ta.j = %d\n",Ta.get_j()); Test Tb(10); printf("Tb.i = %d\n",Tb.get_i()); printf("Tb.j = %d\n",Tb.get_j()); Test *Tc = new Test(30); printf("Tc->i = %d\n",Tc->get_i()); printf("Tc->j = %d\n",Tc->get_j()); return 0; }
运行结果：
Test() Ta.i = 5 Ta.j = 10 Test(int v);v = 10 Tb.i = 20 Tb.j = 30 Test(int v);v = 30 Tc->i = 20 Tc->j = 30
从结果中可以看出：
Test Ta;调用的是 Test() 这个构造函数。
Test Tb(10);和 Test *Tc = new Test(30);调用的是 Test(int v) 这个构造函数。
注意：对象的定义与对象的声明是不同的。例如变量的定义与变量的声明也是不同的。
对象定义：声明对象的空间并调用构造函数。
对象的声明：告诉编译器存在这样的一个变量。
构造函数的手动调用：
一般来说构造函数在定义对象的时候被自动调用，但是在一些特殊情况下需要手动调用。
例如构造对象数组。
实验：创建一个数组类解决数组的安全性问题。
1、创建Intarray.h
#ifndef __INTARRAY_H #define __INTARRAY_H class intArray { private: int arrayLenght; int *Parray; public: intArray (int lenght);//构造函数 bool changeArray(int index,int val);//修改数组中的元素 int getLenght(void);//获取数组长度 bool getArrayData(int index,int& val);//获取数组中的元素 void free(); }; #endif
2、创建Intarray.cpp
#include "intArray.h" intArray::intArray (int lenght)//构造函数 { Parray = new int[lenght];//创建数组空间 for(int i=0; i<lenght; i++)//初始化 Parray[i] = 0; arrayLenght = lenght; } bool intArray::changeArray(int index,int val)//修改数组中的元素 { bool ret = (index>=0)&&(index < arrayLenght);//判断是否越界 if(ret) { Parray[index] = val; } return ret; } int intArray::getLenght(void)//获取数组长度 { return arrayLenght; } bool intArray::getArrayData(int index, int& val)//获取数组中的元素 { bool ret = (index>=0)&&(index < arrayLenght);//判断是否越界 if(ret) { val = Parray[index] ; } return ret; } void intArray::free()// { delete[] Parray; }
3、创建main.cpp
#include <stdio.h> #include "intArray.h" int main(int argc, char *argv[]) { int temp ; intArray TestArray(6); for(int i=0; i<TestArray.getLenght();i++) TestArray.changeArray(i,i); for(int i=0; i<TestArray.getLenght();i++) { TestArray.getArrayData(i,temp); printf("getArrayData(%d) = %d\n",i,temp); } TestArray.free(); return 0; }
运行结果：
getArrayData(0) = 0 getArrayData(1) = 1 getArrayData(2) = 2 getArrayData(3) = 3 getArrayData(4) = 4 getArrayData(5) = 5
标签：就会 pre 构造 类的构造函数 个数 创建 define 对象数组 c++
原文地址：https://www.cnblogs.com/hjxzjp/p/11651330.html
