C++再度学习之笔记一

C++再度学习之笔记一

时间过得真快啊，不知不觉又是一季。。。。。。。。

只剩下了在时光中蹉跎的自己，由于工作之中要用到C++，秉着对曾经学过的知识再度查缺补漏吧，对于笔记顺序有点混乱，我只能说这只是笔记，不是教材。

希望。。。能有些作用吧。。。。

话不多说～直接进入主题！

1、类

（1）类的作用域:


（2）构造函数:
构造函数分两个阶段执行：（1）初始化阶段（2）普通的计算阶段。
注：不管成员是否在构造函数初始化列表中显示初始化，类类型的数据成员总是在初始化阶段初始化，
初始化发生在计算阶段开始之前


构造函数初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，
每个数据成员后面跟一个放在圆括号中的初始化式。构造函数初始化式只在函数的定义中
而不是声明中指定。
注：初始化const对象或者引用类型的对象唯一机会是在初始化列表


（3）this指针:
以下情况必须用this：
（a）、防止命名冲突
class A{
int x,y;
void fun(int x,int y)
  {this.x=x;
  thix.y=y; 
  }
}
（b）、将对象本身的指针或者引用给别的函数时
return this;  // 返回对象本身的指针
return *this;  // 返回对象本身的引用








三个新特征：友元、可变成员、静态成员。

（1）、友元
允许不是那个类的成员但是可以访问它的非公有成员。
如：
class S{
//
friend class Win; 
//...rest of class S


}
友元声明与作用域：友元声明将已经命名的类或非成员函数引入到外围作用域中。此外，
友元函数可以在类的内部定义，该函数的作用域扩展到包围该类定义的作用域。
如：
class S{
//
friend class Win; 
friend void f(){/*...*/}
//...rest of class S


}

（2）静态成员
使用类的static成员的三个优点：
<1>、static成员的名字是在类的作用域中，因此可以避免与其他类的成员或者全局对象名字冲突
<2>、可以实施封装
<3>、static成员是与特定类关联的
但我们在类的外部定义static成员的时候，无须重复指定static保留字，该保留字只在类的内部声明处
static函数没有this指针，static成员是类的组成部分但不是任何对象的组成部分，因此，static成员

函数没有this指针。

2、定义与声明


声明是将一个名称引入程序。定义提供了一个实体在程序中的唯一描述。
声明和定义有时是同时存在的。


只有当extern中不存在初始化式是才是声明。其他情况既是定义也是声明。
     但是在下列情况下，声明仅仅是声明：
       1：仅仅提供函数原型。如void func(int,int);
       2: extern int a;
       3：class A；
       4：typedef声明
       5：在类中定义的静态数据成员的声明


下列情况下 ，定义仅仅是定义：
      1：在类定义之外，定义并初始化一个静态数据成员。如 A::a=0;
      2:在类外定义非内联成员函数。
     声明仅仅是将一个符号引入到一个作用域。而定义提供了一个实体在程序中的唯一描述。
在一个给定的定义域中重复声明一个符号是可以的,但是却不能重复定义,否则将会引起编译错误。
但是在类中的成员函数和静态数据成员却是例外，虽然在类内它们都是声明，但是也不能有多个。
在一个给定的定义域中重复声明一个符号是可以的,但是却不能重复定义,否则将会引起编译错误。

3、复制控制


（1）复制构造函数、析构函数、赋值操作符


复制构造函数：形参与返回值。。。


禁止复制：为了防止复制，类必须显示的声明其复制构造函数为private，
然而类的友元和成员人可以进行复制，如果想要连友元和成员中的复制也禁止，
就得声明一个private复制构造函数但不对其定义。


（2）智能指针
我们定义一个简单类，类里面有指针，对进行类对象赋值操作后，对于该指针指向对象作出改变
都将作用于共享对象，如果删除其中一个对象，则类就会产生一个悬空指针，指向一个不存在的对像。


解决方方法是定义所谓的智能指针。




1）、使用计数
2）、计数类


3）、计数类的使用
4）、赋值与改变
5）、举例
原：
class A{
friend class B;
int *pt;
size_t size;
A(int *p):pt(p),size(1){}
~A(){delete pt;}
};
class B{
public:
B(int*p,int f):flag(f){ a=new A(p);}
~B(){/*~A();*/a->~A(); }
private:
A*a;
int flag;
};
int* p=new int (10);
B* b1=new B(p,1);
B* b2=new B(p,2);
delete b1;//error，A类出现悬空指针


改正：
class A{
friend class B;
int *pt;
size_t size;
A(int *p):pt(p),size(1){}
~A(){delete pt;}
};
class B{
public:
B(int*p,int f):a(new A(p)),flag(f){ }
//copy membersand increment the use count
B(const B&b):a(b.a),flag(b.flag) {++a->size;}
B& operator=(const B&bb){
++bb.a->size;
if(--a->size==0)delete a;
a=bb.a;
flag=bb.flag;
return *this;
}
//if use count goes to 0,delete the A object
~B(){if(--a->size==0)delete a;}
private:
A* a;
int flag;
};
int* p=new int (10);
B* b1=new B(p,1);
B* b2=new B(p,2);
delete b1;


其中B的构造函数之中可以将new A(p)更改为&a，a是A对象。但是此处目的不是在此，
故不讨论。。。
不引起指针问题么？感觉有点玄。。。似乎还有一点没想通。。。还有就是为何在A类析构函数中
要使用delete

4、面向对象与泛型编程


1）、继承，多态
派生类可以继承基类定义的成员并且可以无须改变的使用那些与派生类型具体特性不相关的操作。
C++中基类希望派生类重新定义的函数会标志为Virtual函数（虚函数），希望继承的不能被定义为虚函数。
虚函数的调用是运行时确定，非虚函数的调用是编译时确定，virtual关键字只在类声明中出现，不能在类定义体
之外出现


公有，私有，受保护继承
公有：基类成员在派生类中保持自己的访问级别
私有：基类的所有成员在派生类中为（private）私有成员
受保护：基类的所有成员在派生类中为受保护（protected）成员


2）、动态绑定
C++中通过基类的引用（或指针）调用虚函数的时候，将发生动态绑定。
相关引用（或指针）既可以指向基类对象也可以指向派生类对象，这就是所谓动态绑定的关键，但是
由于是在运行时确定的，所以被调用的具体函数是由实际调用的对象类型所决定的。