wordpress 别名插件,南昌seo关键词排名,杭州建设网址,茂名手机网站制作构造函数-2 构造函数体赋值 在对象创建的时候#xff0c;编译器会调用构造函数#xff0c;给对象当中的成员赋一个合适的初始值。
class Date
{
public:
Date(int year, int month, int day)
{
_year year;
_month month;
_day day;
}
private:
int _year;
int _month;
i…构造函数-2 构造函数体赋值 在对象创建的时候编译器会调用构造函数给对象当中的成员赋一个合适的初始值。
class Date
{
public:
Date(int year, int month, int day)
{
_year year;
_month month;
_day day;
}
private:
int _year;
int _month;
int _day;
};
但是其实本质上上述的操作并不是给成员初始化只能说是给成员赋值整整的初始化只能初始化一次而在构造函数体内能给成员多次赋值。
所以这时候我们就在构造函数中使用初始化列表。
初始化列表 初始化列表以一个冒号开始数据成员之间用 逗号进行分割其中的每个成员变量后面跟 一个放在括号中的初始值或表达式。
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
}; 如上图所示数据成员后面的括号当中就是给这个数据成员初始化值。 看似这个初始化和 赋初值看似差不多但是在有些情况下初始化列表才能解决。 【注意】
每一个成员最多只能再初始化链表当中出现一次。有些成员必须在初始化列表初始化
上述必须初始化的成员有
引用成员变量const成员变量自定义成员类型当其类中没有默认构造函数 比如我们直接使用构造中 直接赋初值来初始化这个 const 的成员 像上述就报了必须初始化常量限定····这个错这就代表着要在 定义的时候初始化那么我们在赋值的时候是不行的。 那么我们就理解实质了也就是说如我们不使用初始化列表那么我们在构造函数中的初始化就是直接 赋初值那么这种方式是不能初始化 在定义的时候就需要初始化的成员的。 也就是说在C当中这个位置不认为是初始化的地方 如上图这个只是赋值。 在这个位置才认为是 初始化。
我们之前说过当我们初始化一个成员的时候如果是内置类型不进行处理 但是也不是都不处理如果这个内置类型在类当中是定义给了值的 这个不是初始值这个是 给 初始化列表的缺省值也就是说如果我们不对这个内置类型进行处理那么这个x 就会被 赋 1 缺省值这个值如果我们在初始化列表当中对这个x 进行了赋值那么这个x 就是 在初始化列表当中初始化的值。 同样如果对象是 没有默认构造函数那么我们在创建这个对象的时候就会报错 如上图我们在B类当中创建一个了一个 A类的对象但是如下图所示没有缺省参数而我们创建的是无参的构造函数来创建这个对象的我们构造函数当中没有默认构造函数那么就会报错 当我们在A 的构造函数中 的 初始化列表当中去的 调用这个对象的构造函数去创建这个对象那么就不会报错 而且我们发现成功赋值。
所以我们建议我们能使用初始化列表就用初始化列表因为不管你是否使用初始化列表对于自定义类型成员变量一定会先使用初始化列表来进行初始化因为初始化列表是这个些成员定义的地方但是也不是意味着所有的初始化都可以用初始化列表。
class Stack
{
public:Stack(int Top, int capacity):_a((int*)malloc(sizeof(int))),Top(Top),capacity(capacity){if (_a NULL){perror(malloc fail);exit(-1);}// 初始化数组memset(_a, 0, sizeof(int) * capacity);}protected:int* _a;int Top;int capacity;
};
比如上述例子我们在实现栈的构造函数的时候我们希望在 初始化列表当中去 初始化 _a 指针指向一块空间。那么我们是可以实现的。
但是我们知道malloc函数是有可能会开辟空间失败的所以我们要进行判断但是这个判断在是在 初始化列表当中不能做到的我们就只能再的 构造函数中实现那既然有这样的场景那么假设我们还想初始化我们创建的数组那么我们还需要再使用这个函数来进行处理如上述例子一样。
这些都是初始化列表不能实现的而且这种情况很多时候不止一种可能会有很多行我们这里想表达的意思是总有一些工作时初始化列表做不完的。那么我们就可以在函数体当中去实现。
再比如我们要动态开辟二维数组那其中必然就有一个循环这也是初始化列表不能实现的。 成员变量在类中声明次序就是其在初始化列表中的初始化顺序与其在初始化列表中的先后次序无关。 如下例子
class A
{
public:A(int a):_a1(a), _a2(_a1){}void Print() {cout _a1 _a2 endl;}
private:int _a2;int _a1;
};
int main() {A aa(1);aa.Print();
} 上述例子输出的不是 1 1 而是 1 随机值。 因为上述例子我们是声明的 _a2 这个变量那他就会先初始化那么我们在初始化列表当中写的是 _a2(_a1) 此时 _a1 还没有会被初始化所以是随机值。先走 _a2(_a1) 再走 _a1(a)。 上述例子还不是很严重我们在之前实现栈的构造函数的时候如果想下述这样写就会出错了 我们发现上述在初始化 _a 的时候capacity是没有初始化的也就是说现在 的 capacity 是一个随机值那么我们以一个随机值来开辟空间大小就会出现很严重的问题。 所以我们一般把声明的顺序和初始化的顺序保持一致。 explicit关键字 隐式类型转换 例子 B b(10); //1B c 10; //2 代码1是在调用 B 这个类的构造函数来创建这个对象那么 代码2是在干嘛呢
我们发现他是一个隐式的类型转换由整形类型转化成自定义类型。
他是先用 10 利用 B 的构造函数来创建一个 临时对象这个临时对象的类型就是 自定义类型B然后 c 再用 B 当中的拷贝构造函数去 把 临时对象拷贝给 c 这个对象。 我们发现上述即调用了 构造函数还调用了 拷贝构造函数但是编译器不想这样做他不像上面这个代码即调用构造函数有调用拷贝构造函数所以一遍像上述情况编译器会进行优化。 像上述例子他会直接使用 10 这个整型数据来进行 构造。 我们把 B的拷贝构造写出来其中加入打印看看构造函数和 拷贝构造函数是否被调用
class B
{
public:B(int n):_n(n)//,aobj(10){cout B::B(int) endl;}B(const B b):_n(b._n){cout B::B(const B b) endl;} protected:const int _n;
};int main()
{B b(10); //1B c 10; //2return 0;
} 输出 我们发现拷贝构造函数并没有被调用此处就是被编译器优化了如果按照本来的实现过程应该还有临时对象的创建。 构造函数和 拷贝构造函数都是 构造函数除了老的编译器现在的编译器一般都不会容忍在同一个表达式当中重复的调用构造函数。 上述例子也是只要是在一行当中的重复的调用构造函数都会被优化。 上述两个例子ra1 会 优化 ra2 不会优化我们可以看到两种情况下ra2 的代码明显大多了还需要调用 赋值重载函数。 我们现在来举一个反例来验证我们刚刚说个创建临时对象这一过程 B pb1 2; //代码1 pb1 去引用之前的 b 和 c 都是可以的 但是我们上述引用的是一个整形 2 这就不行了报错 但是如果我们把这个引用转换成 const 的就可以了 const B pb2 2; //代码2 我们发现上述代码编译通过了。
我们上述定义的是 B 类型的引用类型编译器在这时候就不能在进行优化了上述代码的实现过程就是我们之前说的创建一个 临时对象来进行 赋值像上述的代码2就是用2 调用构造函数创建了一个 临时对象这里的 pb2 引用的就是 这个临时对象。
而临时对象具有常性所以之前的报错是 也 我们的引用类型不是 const 所修饰的引用当我们用const 修饰之后就可以编译通过了。如下图所示 此时我们运行这个代码输出 我们发现只调用了一次构造函数。
那么像上述的这种创建一个临时对象来让一个自定义类型接收一个不是这个类型的值然后来创建这个对象主要是为了实现像下述代码这种情况
class list
{
public:list(const string st){}
};int main()
{string name1(李四);list LS1(name1); // 代码1list LS2(李四); // 代码2return 0;
}上述代码 1 和 代码 2 肯定是 代码2 的方式比较方便代码能实现这种情况的是因为“李四” 这个字符串就和 const String 之间就发生了 隐式类型转换和之前的 const B pb2 2; 是一样的。
当我们 不加 const修饰就报错了 explicit关键字 根据上述的 list 类的描述我们知道构造函数不仅可以构造与初始化对象对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数还具有类型转换的作用 那么我们在自定义类型实现构造函数的时候我们就可以在函数名之前加一个 explicit 这个关键字来防止类似于 B b 10 这样的 隐式类型转换 Static 成员
假设我们现在想要记录当前我们实现的类到底创建了多少个对象那么我们可以在 全局当中定义一个变量scount用这个变量来计算我们创建了多少个 对象当我们调用这个类当中的 构造函数或者是拷贝构造函数的时候我们就 scount如果我们调用的是 析构函数就 scount--。从而来记录当前有多少个这个类的对象。
static int _scount 0;class A
{
public:A() { _scount; }A(const A t) { _scount; }~A() { --_scount; }
};void func(A aa)
{cout __LINE__ : _scount endl;return;
}int main()
{cout __LINE__ : _scount endl;A aa1;A aa2;func(aa2);cout __LINE__ : _scount endl;
} 输出 我们上述使用 __LINE__ 这个宏来打印当前行数上述就输出了 每一行代码的情况下当前有多少个对象。
当然不管你在 局部全局还是在 对象当中去创建这个对象只要是创建对象都需要构造函数或者是 拷贝构造函数那么只要调用计数器就会只要调用析构函数计数器都会 --。
如上述我们在函数中创建的 对象在对象当中打印这个 计数器发现是3说明当前已经创建这个局部的对象但是在函数调用结束之后对象会调用析构函数进行销毁那么计数器就会--所以我们在主函数当中打印的计数器的值是 2。
但是我们上述使用的全局变量这样做不太好所以我们在定义在定义类型的时候可以对类似这样需要全局实现的 变量进行封装把这边变量封装到 自定义类型当中。
Static 成员 声明为static的类成员称为类的静态成员用static修饰的成员变量称之为静态成员变量用static修饰的成员函数称之为静态成员函数。静态成员变量一定要在类外进行初始化。 这里我们要搞清楚普通成员变量和 静态成员变量这两个的区别普通成员属于类的当前对象而 静态成员变量属于的是类的每一个对象因为是静态的他的生命周期是全局的而普通成员的生命周期是 这个对象的生命周期。 因为 静态成员变量是属于全局的所以我们在 对象当中利用构造函数去初始化是不行的 如上图报错了。
静态成员变量只能再 全局位置 类外面进行 定义。像下面这样定义这个静态成员变量。
int A::_scount 0;
那么像我们之前实现的 _scount 是 protected 的那么我们就不能直接 A::_scount 这样访问了除非这个 _scount 是 public 的。 当然为了封装我们一般不会是 共有的一般是私有的public的和 全局的每什么区别达不到封装的效果。
所以为了取到 不是 public的 静态成员变量我们就创建一个 静态成员函数来取到 其中的 静态成员变量。 静态成员函数没有隐藏的this指针不能访问任何非静态成员 static int Get_Scount(){return _scount;}
因为这个静态成员函数不能访问非静态的成员他能帮我们取到 静态的成员的值所以我们使用这个函数来取到数据又不会破坏封装性。
class A
{
public:A() { _scount;}A(const A t) { _scount; }~A() { --_scount; }static int Get_Scount(){return _scount;}protected:static int _scount;
};int A::_scount 0;void func(A aa)
{cout __LINE__ : A::Get_Scount() endl;return;
}int main()
{cout __LINE__ : A::Get_Scount() endl;A aa1;A aa2;func(aa2);cout __LINE__ : A::Get_Scount() endl;
}
我们可以通过 . 或者是 类名:: 来访问静态成员函数。
静态成员变量是不能给缺省值的因为静态成员变量的初始化不在 初始化列表当中而是在 全局当中。 关于静态和非静态的关系同类中 非静态可以调用非静态而静态 只要是不受指定类域和访问限定符的限定就可以访问。 因为 访问非静态的成员函数的访问需要 this 指针而在静态成员函数中没有 this 指针。
设计一个类只能在 栈/堆上创建对象
如下在C当中的对象存储的位置
class A
{
public:protected:int _a 1;int _b 1;
};int main()
{static A aa1; // 静态区A aa2; // 栈A* ptr new A; // 堆return 0;
}
我们发现我们创建对象的地方有好几个而且像上述一样实现的类用户可以在 静态区 栈 堆 上随便选个位置来创建对象。
我们可以把 构造函数 的访问权限 设置为 protected 私有的 这样我们在类外部就不能随便去调用这个构造函数去创建对象。 那么问题来了既然是私有的那么我们在类外部怎样去 调用这个 构造函数 呢
我们可以定义 public 的 成员函数既然在来外面不能调用那么我们就在 类当中去调用构造函数如下所示 这样我们可以通过调用这些函数 来在对应的 位置创建对象。
但是向上述还是有问题既然这个函数是成员函数那么我们如果在类外面访问这个函数呢
我们如果想访问成员函数必须通过对象来访问但是现在我们不能创建对象。
这时候静态的成员函数就可以帮我们解决这个问题因为静态的成员函数就可以在类外面进行调用他是全局的不在类当中。
class A
{
public:static A GetStackA(){A aa;return aa;}static A* GetHeapA(){return new A;}protected:int _a 1;int _b 1;
};如上述这种我们就可以只创建对应的函数来达到只能再某一个区域创建对象的这种限制。 例题
求123...n要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句A?B:C。 这里就可以利用这个 静态成员通过调用n次构造函数来计算出从1 加到 n 的值。这里我们想到创建一个这个类的数组数组元素个数为 n。
class Sum
{
public:Sum(){_sum _i;_i;}int GetSum(){return _sum;}protected:static int _sum;static int _i;
};int Sum::_sum 0;
int Sum::_i 1;class Solution {
public:int Sum_Solution(int n) {Sum a[n];return a[0].GetSum();}
};
