C++ 技术细节 (1)

子类与父类中的静态成员:

若基类中有静态成员，那么子类对象和父类对象共享该成员，即对通过子类对象修改静态成员，会影响到父类中的静态成员。

         class Base

                {

                        public:

                                       static int sum;

               };

               int Base::sum=0;

 

          class Derive : public Base{}

 

          //Test

          Base::sum = 1;

          Derive::sum =2;

          cout<<Base::sum<<endl; // 2

---

参数的缺省值:

 

参数缺省值只能出现在函数的声明中，而不能出现在定义体中。例如：

void Foo(int x=0, int y=0); // 正确，缺省值出现在函数的声明中

void Foo(int x=0, int y=0){} // 错误，缺省值出现在函数的定义体中

如果函数有多个参数，参数只能从后向前挨个儿缺省，否则将导致函数调用语句怪模怪样:

正确的示例如下：                               错误的示例如下：

void Foo(int x, int y=0, int z=0);                                  void Foo(int x=0, int y, int z=0);

---

内联函数：

 

以目标代码的增加为代价来换取时间的节省。函数体代码不是很大，但又频繁地被调用的函数应定义成内联函数

关键字inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用，除非在声明时就定义了函数。

 

如下风格的函数Foo 不能成为内联函数：

inline void Foo(int x, int y); // inline 仅与函数声明放在一起

void Foo(int x, int y){}

 

而如下风格的函数Foo 则成为内联函数：

inline void Foo(int x, int y) {}// inline 与函数定义体放在一起

所以说，inline 是一种“用于实现的关键字”，而不是一种“用于声明的关键字”.

　　1.在类声明的内部声明，而在类声明外部定义叫做显式内联函数，如：

　　class display

　　{

　　int t;

　　public:

　　void output(void)

　　}

　　display object;

　　inline void display::output(void)

　　{

　　cout << "i is " << i <<""n";

　　}

　　2.在类声明的内部定义，叫做隐式内联函数，如：

　　class display

　　{

　　int t;

　　public:

　　inline void output(void)

　　{cout<<"i is "<< i << ""n";}

}

 

构造和析构函数的内联

构造和析构函数可以内联, 但是由于编译会在这两个函数内安插许多代码 所以最好不要内联这两个函数.
否则生成的代码体积可能过大。
如果内联函数中有静态变量 则会产生多个静态变量的副本.

 

---

 

成员对象初始化顺序由其在类中的声明顺序决定：

成员对象初始化的次序完全不受它们在初始化表中次序的影响，只由成员对象在类中声明的次序决定。这是因为类的声明是唯一的，

而类的构造函数可以有多个，因此会有多个不同次序的初始化表。如果成员对象按照初始化表的次序进行构造，这将导致析构函数无法得到唯一的逆序

 

---

 

析构函数何时为虚？

 

当类中有至少一个虚函数时，则该类作为基类时他的析构必须为虚。否则当用指向子类对象的基类指针　 

删除子类对象时只调用基类的析构函数而不会调用子类对象的析构函数。

 

---

 

哪些运算符不能重载

不能重载的运算符只有5个：

类属关系运算符     . 

成员指针运算符     .*

作用域分辨符       ::

sizeof运算符

三目运算符“?:”。

 

---

 

strcpy 函数用法

char *strcpy( char *strDestination, const char *strSource );

The strcpy function copies strSource, including the terminating null character

 

---

 

覆盖与隐藏：

覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函数！这种覆盖，要满足两个条件
　(a)有virtual关键字，在基类中函数声明的时候加上就可以了
　(b)基类CB中的函数和派生类CD中的函数要一模一样，什么叫一模一样，函数名，参数，返回类型三个条件。

隐藏指的是：子类无法调用到基类中某个的函数

满足任一条件即可。

1,同名同参无virtual
2,同名不同参不管有无virtual

 

---

成员初始化列表

对象构造分两步：
1.    分配内存(operator new) 初始化类内部数据
2.    调用类的构造函数
也就是说调用构造函数之间会前初始化类中的成员 也就是对所有成员调用构造函数。调用哪个构造函数呢？
其结果与initializer list 有关。具体步骤如下：

1)如果没有在initializer list中没有对该对象的初始化操作则该成员对象的默认构造函数（不需要指定参数的构造函数）
将会被调用，若无默认构造函数则编译会出错。然后进入类的构造 进行赋值操作（如果有相应赋值的代码）。
对于此情况 该成员对象一共调用了两个函数：一个是它自已的构造函数，另一人是这自已的operator =.

2)若成员对象在initializer list中初始化 则只需对该对象调用copy constructor即可。
对于此情况 该成员对象只调用了一个函数：自已的 copy constructor.

 

class A 
{ 
     public: 
           void show() {};  //编号1 
           void rose(int a) {}   //编号2 
}; 
class B:public A 
{ 
     public: 
           void show() {}; //编号3 
           void rose(int a, int b) {};  //编号4 
};

class Base 
{
public:
  virtual void f(int x) {};
};
class Derived: public Base 
{
public:
  virtual void f(double *pd){};
};

Base * pb = new Derived;
Pb->f(10);//Base::f(int x)
Derived *pd = new Derived;
pd->f(10);  // error! 由于子类隐藏了基类中的f()，所以无法调用到该函数，出现编译错误

类B中的show()和rose()明显是隐藏了类A的show()和rose()

隐藏的理解:
B类中其实有两个show(),两个rose();
但为什么不叫重载呢?你会这样想,但我可以告诉你,因为类B中的两个show(),两个rose(),不是都可以被类B对象调用的.
重载是指同一类中的函数而言的。
//----1----//
编号1和编号2,在类B中哪怕存在,但只能通过类A的指针调用,而不能通过B类对象调用,如:

程序代码：
A *p = new B; 
p->show();  //A::show
p->rose(3); //A::rose(int a)
p->rose(3,5); //error
//----2----//
编号3和编程4,只能通过类B对象调用,而不能通过类A的指针调用,如:

程序代码：
B b; 
b.show();

 

---

1.字符串大小写转换

2.写一个加密程序和一个解密程序