C++学习（32）

1. 

#include<iostream>#include<string.h>using namespacestd;struct A{      int a;      char b;}; class B{};class C{      char b[0];};int main() {       cout<<sizeof(A)<<""<<sizeof(B)<<" "<<sizeof(C)<<endl;      return 0;}

分析：类的实例化是在内存中分配一块地址，每个实例在内存中都有独一无二的二地址。同样，空类也会实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化后就有独一无二的地址了。所以，空类的sizeof为1，而不是0. 多重继承的空类的大小也是1.

 

2.

 #include<iostream>#include<string.h>using namespace std;class A{    public:    int_a;    A(){       _a=1;    }    voidprint() {       cout<<_a;    }}; class B:public A{    public:       int_a;       B(){           _a=2;       }};class C{    charb[0];};int main() {    Bb;    b.print();    cout<<b._a;    return0;}

分析：因为在继承的时候，允许子类存在与父类同名的成员变量，子类会屏蔽父类的成员变量，他们同时存在。 因为给孩子类中没有定义print函数，所以会按照就近原则去寻找父类中是否有print函数。恰好父类中有这个函数，于是调用父类的print函数。所以b.print（）这个函数会调用父类的a变量。

 

子类公有（public）继承父类，所以子类可以通过对象访问父类的公有成员函数，由于调用的是父类的公有成员函数（该函数中的this指针存放的是父类对象的地址），所以打印的是父类A的_a。

 

3、
C++真正正式公布的标准就三个：C++98、C++03、C++11。
其中C++98是第一个正式C++标准，C++03是在C++98上面进行了小幅度的修订，C++11则是一次全面的大进化（C++0x是C++11标准成为正式标准之前的草案临时名字）。

 

class foo() {foo(){};};class boo:public foo {boo():foo(){};};

A c++03    B c++0x    C c++11       D c++98   E 都不正确

分析：委托构造是对同一类而言，参数类型不同的构造函数可以调用自己的其他构造函数，这个地方就是派生类调用基类的构造，所以并不是委托构造。但是，这个题出了点小插曲，就是foo()在foo类里默认是private的，所以编译时不通过，可能是题目的疏忽。

 

委托构造函数同一个类的一个构造函数调用另一个构造函数。这道题应该选E，因为根本编译不通过。父类的private构造函数子类无法通过任何方式访问到。

 

4. Linux下对文件操作有两种方式：系统调用(system call)和库函数调用(Library functions)。系统调用实际上就是指最底层的一个调用，在linux程序设计里面就是底层调用的意思，面向的是硬件。而库函数调用则面向的是应用开发的，相当于应用程序的api。

简明的回答是：函数库调用是语言或应用程序的一部分，而系统调用是操作系统的一部分。

 

Pwrite是系统调用，而其他的库函数。

 

fcntl 文件控制

open 打开文件

creat 创建新文件

close 关闭文件描述字

read 读文件

write 写文件

readv 从文件读入数据到缓冲数组中

writev 将缓冲数组里的数据写入文件

pread 对文件随机读

pwrite 对文件随机写

lseek 移动文件指针

_llseek 在64位地址空间里移动文件指针

dup 复制已打开的文件描述字

dup2 按指定条件复制文件描述字

flock 文件加/解锁

poll I/O多路转换

truncate 截断文件

ftruncate 参见truncate

umask 设置文件权限掩码

fsync 把文件在内存中的部分写回磁盘

 

5.

#include<iostream>#include<string.h>using namespace std;int main() {    staticchar*s[]={"black","white","pink","violet"};    char**ptr[]={s+3,s+2,s+1,s},***p;    p=ptr;    ++p;    printf("%s",**p+1);    return0;} 

6．

#include<iostream>#include<string.h>using namespace std;class B0{    public:       virtualvoid display() {           cout<<"B0::display"<<endl;       }};class B1:public B0{    public:       voiddisplay() {           cout<<"B1::display0"<<endl;       }};class D1:public B1 {    public:       voiddisplay() {           cout<<"D1::display0"<<endl;       }}; void fun(B0 ptr) {    ptr.display();}int main() {    B0b0;    B1b1;    D1d1;    fun(b0);    fun(b1);    fun(d1);    return0;}

分析：此题的关键点在于fun函数，传入的参数是一个类的对象，这样，派生类作为参数传入的时候，会把自动的类型转换为基类对象，这样，display就只是执行基类的函数了。选B0::display()　B0::display()　B0::display()

void fun(B0 ptr) {   ptr.display();}//这里使用的不是按地址传递，程序在这里转化为基类对象，直接调用基类的成员函数。如果是指针传递，改变为B0*ptr,ptr->display()，可以实现多态。

改完后的程序为：

#include<iostream>#include<string.h>using namespace std;class B0{    public:       virtualvoid display() {           cout<<"B0::display"<<endl;       }};class B1:public B0{    public:       voiddisplay() {           cout<<"B1::display0"<<endl;       }};class D1:public B1 {    public:       voiddisplay() {           cout<<"D1::display0"<<endl;       }}; void fun(B0 *ptr) {    ptr->display();}int main() {    B0*b0=new B0;    B1*b1=new B1;    D1*d1=new D1;    fun(b0);    fun(b1);    fun(d1);    return0;} 

fun(B0　*ptr)：使用指针传入结合virtual虚函数，相当于在ptr指针指向的内存空间里边为子类虚函数的实现预留了接口，这样如果传入的是子类，则编译的时候系统会根据子类类别动态加载子类函数；而如果形参不是指针，在编译的时候就不会给子类的虚函数实现留接口，也就无从动态加载子类函数了。另外，如果基函数没有设置函数为virtual类型，同样也不会留接口，不会加载子类函数。

 

在c++中的继承中，如果基类声明了一个函数为虚函数，那么在派生类中不用声明同名函数为虚函数（不需要加virtual）也可以实现该函数为虚函数。虚函数的动态绑定仅在基类指针或引用绑定派生类对象时发生，fun的形参不是指针，所以调用哪个版本的函数编译时就已经确定，根据形参静态类型确定调用B0的成员。

 

应通过指针或引用调用虚函数，而不要用对象名调用虚函数。以派生类对象b1赋值给基类对象b0,并调用Display函数，虽然可以编译通过，但Display（）函数却是基类B0的函数。C++中一定要用指针或引用来调用虚函数，才能保证多态性的成立。

 

７．输出数据为：８０　８

#include<iostream>#include<string.h>using namespace std;int main() {    char*p[10],(*p1)[10];//p是一个指针数组，p1是一个指向“包含10个char变量的数组”的数组指针     cout<<sizeof(p)<<""<<sizeof(p1)<<endl;    return0;}

分析：重点理解p跟谁结合了，跟[]结合，则p就是一个数组;跟*结合，p就是一个指针；

首先[]()的优先级一样，均大于* char *p[10]，p与[]结合，所以p就是一个数组，数组的元素比较特殊，是指针，指针大小为8，所以是10*8=80；

char(*p1)[10]，与*结合，所以是一个指针，大小为8；

 

补充：什么是数组名降级？数组退化？
数组名降级和数组退化是一个概念，它是在某些情况下，对数组的引用会退化为指针。点击打开链接

 

8.

#include<iostream>#include<string.h>using namespace std;int i=1;class MyCls{  public:    MyCls():m_nFor(m_nThd),m_nSec(i++),m_nFir(i++),m_nThd(i++){       m_nThd=i;     }     void echo() {       cout<<"result:"<<m_nFir+m_nSec+m_nThd+m_nFor<<endl;     }  private:     int m_nFir;     int m_nSec;     int m_nThd;     int &m_nFor;};int main() {  MyCls oCls;    oCls.echo();  return 0;}

分析：构造函数中变量的初始化顺序是按其定义的顺序，与初始化列表无关、

首先要明白变量初始化的顺序是其声明的顺序,跟初始化列表中的顺序无关。所以变量的初始化顺序为m_nFir(i++)，m_nSec(i++)，m_nThd(i++)，&m_nFor(m_nThd);
i初始值为1，所以经过初始化列表初始化以后m_nFir=1，m_nSec=2，m_nThd=3，m_nFor为m_nThd的一个引用。
并且此时i的值为4，构造函数中执行语句m_nThd=i后，m_nThd=4,m_nFor是它的一个引用，自然值也为4。
输出结果m_nFir+m_nSec+m_nThd+m_nFor=1+2+4+4=11。