C++学习（23）

1.分析下述代码运行：

#include<iostream>
using namespacestd;
int main()
{
       int a[10]={0,1,2,3,4,5,6,7,8,9};
       int *p=a;
       cout<<p[6]<<""<<*(a+6)<<" "<<*(p+6)<<""<<p+6<<endl;
       return 0;
}

2、用关键字virtual修饰的成员函数叫做虚函数，虚函数是为了实现多态而存在的，必须有函数体；

纯虚函数的声明，是在虚函数声明的结尾加=0，没有函数体。在派生类中没有重新定义虚函数之前是不能调用的纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加"=0"

如果一个类中至少含有一个纯虚函数，此时称之为抽象类。所以抽象类一定有纯虚函数

基类类型的指针可以指向任何基类对象或派生类对象

 

3、下列代码输出结果？

auto fn(unsignedchar a) {

       cout<<std::hex<<(int)a<<endl;

}

fn(-1);

分析：32位-1的原码1000 0000 0000 0001

补码1111 1111 1111 1111（求反加一）

则fn()后8位为1111 1111
int 后0000 0000 1111 1111
Hex16进制后ff

 

int型-1的存储方式为补码（32位，4字节），1111  1111  1111  1111

转换为unsigned char（8位，1字节）发生字节截断，取最后八位为1111  1111 ；

再转换为int后为0000 0000 0000 0000 0000 0000 1111 1111 ，即为ff

 

4、

#include<iostream>
#include<string.h>
using namespacestd;
struct st_t{
       int status;
       short *pdata;
       char errstr[32];
};
int main()
{
       st_t st[16];
       char *p=(char *)(st[2].errstr + 32);
       cout<<p-(char *)(st);
       return 0;
}

st_t大小为40，设st起始地址为0，str[2].errstr起始地址为40*2+8=88。

p存储的地址为88+32，结果显然为120

 

5. 面向对象的五大基本原则：

单一职责原则（SRP）

开放封闭原则（OCP）

里氏替换原则（LSP）

依赖倒置原则（DIP）

接口隔离原则（ISP）

 

s(Single-Resposibility Principle):单一职责原则

o(Open-Closed principle ):开放封闭原则

l(Liskov-Substituion Principle):里氏原则

i(Interface-Segregation Principle ):接口隔离原则

d(Dependecy-Inversion Principle ):依赖倒置原则

一个单词：立方体(solid),很好记!!!

 

五个基本原则：

单一职责原则（Single-Resposibility Principle）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。

开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。

Liskov替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。

依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。

接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口

 

6．使用 char *p = new char[100];申请一段内存，然后使用delete p释放：不会造成内存泄露，但不建议使用。

C++告诉我们在回收用 new 分配的单个对象的内存空间的时候用 delete，回收用 new[] 分配的一组对象的内存空间的时候用 delete[]。

关于 new[] 和 delete[]，其中又分为两种情况：(1) 为基本数据类型分配和回收空间；(2) 为自定义类型分配和回收空间。

基本类型的对象没有析构函数，所以回收基本类型组成的数组空间用 delete 和 delete[] 都是应该可以的；但是对于类对象数组，只能用 delete[]。

所以一个简单的使用原则就是：new 和 delete、new[] 和 delete[] 对应使用。

点击打开链接（详细学习）