C++之程序设计方法

一、程序设计概念等

结构化程序设计特点:

程序设计=数据结构+算法
程序内容=过程+过程调用

面向对象的程序设计方法:

    程序=对象+消息
    面向对象=对象+类+继承+消息

任何对象都具有属性(数据)和操作(方法)
具有强大的继承性

关系:

  1. 聚集;2)继承;3)实例化
    类与抽象数据类型:对象是类的实例,对象可以使用类中的函数
    • 对类的定义:
      (最低限度)类名(class name)、外部接口(external interface)、内部实现(implementation)
  • 外部接口
    公共成员变量
    公共成员函数
  • 内部实现
    - 类的内部实现对用户是隐藏的
    - 每一个操作符 对应内部实现的具体操作
    - 内部实现是私有的

属性:数据成员
方法:成员函数

  • public实现类的接口,private隐藏类的实现

抽象

  • 数据抽象:某类对象共有的属性和状态

  • 行为抽象: 共有的行为或功能特征

  • 继承
    使用多继承机制,将增加命名冲突出现的可能性,表现形式:

  1. 派生类与某个基类之间发生命名冲突
  2. 基类和基类之间发生命名冲突
    解决方法: 使用域解析符

接口与组件

  • 接口的作用: 为不相关的类提供通用的处理服务

二、从 C 到 C++

区别

  • <iostream> 和 <iostream.h>不一样,是两文件,里面的代码不一样。当使用<iostream>时,相当于在c中调用库函数,使用的是全局命名空间,也就是早期的c++实现;当使用<iostream.h> 时,该头文件没有定义全局命名空间,必须使用namespace std;这样才能正确使用cout。

  • const 定义时,定义了常量的类型,define只是简单的文本替换;使用const定义常量是一个说明语句,以分号结束,define是一个预处理命令,缺乏类型检测机制。const是左结合的类型修饰符。

  • 强制类型转换:
    static_cast: 强制类型转换
    const_cast: 去掉常数性
    dynamic_cast: 用于继承层次中的类型转换
    reinterpret_cast: 改变指针类型或将指针与整型转换

  • string 类型的索引都是从0开始的

  • 内联函数

    • 从源代码层看,有函数的结构,在编译后,却不具备函数的性质
    • 避免函数调用的开销,避免调用函数对栈内存开辟所带来的消耗

int add(int x, int y=10) //right
int add(int x=10,int y) //error

  • 常见编程错误:
    1. 操纵符作用于数据流中,除了控制域宽的操纵符(控制域宽的操纵符在输出了一个字符串和数字后自动清0)之外,其他所有的操纵器所造成的影响具有持久性。不要误以为在语句结束后所有的输入输出设置都恢复为默认值。
    2. 混用C、C++的输出输入功能,可能会导致不可预料的错误,使用函数 ios::sync_with_stdio()可消除这种隐患。
    3. 关键字inline用于函数声明而不是函数定义。

三、类

基本规则

  • 使用class关键字,类成员在默认状态下是私有的;
    使用struct关键字,类成员在默认状态下则是公有的。
  • 类成员函数的定义方法:
    1. 在类声明之中声明,在类声明之外定义;
    2. 在类声明之中声明及定义(inline),即为内联方式。
    3. 在进行成员函数声明的时候使用inline关键字,可将原本定义在类声明之外的成员函数强制变为内联函数。
  • 在程序中使用类:
    1. 通常将类声明放到.h中,这样在使用时通过#include将类声明包含进来;
    2. 通常将成员函数的定义放到cpp中;
    3. 不要将类外定义的成员函数放在.h中某一位头文件通过#include被多个不同的文件所包含的话可能出现函数重复定义错误。
  • 对象可以采用传值方式传递给函数,也可以采用引用的方式,一般来说应该采用引用方式进行对象的传递和返回,而不是采用传值的方式来进行(*因为传值方式来传递和返回对象时会降低效率并将面临对象间的拷贝操作,从而使数据增大,浪费内存。
    //引用方式比传值方式效率高:

person a;
void f(person b) {......};
f(a); //该调用要将对象a复制到对象b中
void g(person& c) //引用方式
{......};
g(a); //该引用调用,不复制对象

  • 将成员函数标记为const可以预防对该函数所属对象的数据成员的误写,同时有些编译器还可对这种情况进行一些优化;一个const成员函数仅能调用其它const成员函数。

  • 某函数如果采用const返回,则其返回值只能赋给一个const类型的局部变量;

  • 如果该const返回值是一个类的指针或者引用的话,则不能用该指针或引用调用该类的non-const成员函数,因为这些函数可能会改变该类的数据成员的值。

  • 构造函数与析构函数

    1. 有些函数在调用时不需要显式地提供函数名,编译器会自动调用。而类构造函数可有多个,类析构函数最多一个。
    2. 构造函数不能有返回类型,固:

    void Person(); //Error

  1. 一个类可以有多个构造函数,也就是说可以对构造函数进行重载,但每个构造函数必须拥有不用的函数签名。

    Person(){name="Unknown";}//无参数
    Person(const string& n);//函数类型为const string引用
    Person(const char* n);//为C风格字符串

4.如果类的设计者不提供拷贝构造函数,编译器会自动生成一个:将源对象所有数据成员的值逐一赋值给目标对象相应的数据成员。

5.拷贝构造函数:创建一个新的对象,此对象是另外一个对象的拷贝
6.转型构造函数:用于类型间的转换,只有一个参数
7.拷贝构造函数的原型:必须是引用

Person(Person&)
Person(const Person&)
Person(Person); //Error

拷贝构造函数可以有多于一个的参数,但是第一个以后的所有参数都必须有默认值:

Person(const Person& p,bool married=false);

8.什么时候应该为一个类设计一个拷贝构造函数?
答:如果一个类包含指向动态村存储空间指针类型的数据成员,则就应为这个类设计拷贝构造函数。
9.转型构造函数是一个单参数的构造函数,它可以将一个对象从一种数据类型转换为另一种数据类型。
10.转型构造函数可替代函数重载机制。
11.对const类型的数据成员进行初始化时不能直接赋值。
对const类型的数据成员进行初始化时必须为构造函数添加一个 初始化列表。
>class C{
public:
C(){x=0;//OK
c=0;//****ERROR:c is const
C():c(0) {x=-1;} //right(添加初始化列表)}
private:
int x; const int c;}
12.当使用动态方式为一个对象分配存储空间时,C++操作符new和new[]比C函数malloc和calloc做得更好。因为操作符new在分配存储空间的同时,还会调用相应的构造函数,而malloc和calloc无法完成这个任务。
13.使用关键字static修饰的类的成员,称之为类成员(静态成员),包括:类数据成员和类成员函数。这种成员属于类本身,而不属于类的对象。
类数据成员(静态数据成员)特点:1)为同一个类的所有对象共享/2)类内声明,类外定义(不是必须的)。
14.类数据成员(静态数据成员)使用方式:对象明.静态数据成员名;对象指针名->静态数据成员名;类名::静态数据成员名
15.错误的调用一个对象成员函数,把它作为类的类成员函数来使用:

class C{
  public:
    void m(){/*...*/}  //nonstatic: object method
    static void s() {/*...*/} //static: class method
  };
  int main()
{
    C c1; c1.m(); // OK
    c1.s(); //OK
    C::s(); //OK ,s is static
    C::m(); //***ERROR: m:m is not static}
  1. 一个static数据成员在类的声明内被声明,错误地将static数据成员定义在程序块内:

class C{static int c;//declared};
int main(){ int C::x; //****ERROE:defined inside a block!}
//right way
int C::x; //define static data member
int main(){} //即使x是私有地,也要按同样的方式来定义它。
17.错误地针对一个指向对象的指针来使用成员选择操作符
class C{public: void m(){}};
int main(){
C c1;//define a C object
C* p;// define a pointer to a C object
p = &c1; // p points to c1
p.m(); //*** ERROR: member operator illegal!
c1.m(); //OK,c1 is an object}
void f(C& r)
{ r->m(); //***ERROR: r is reference ,not a pointer
r.m();//OK :r is reference can use 成员选择操作符. }
即:对象和对象引用不能使用指针操作符->!!
成员选择操作符仅能由对象活对象引用所使用,指向对象的指针可以使用指针操作符->来访问他们的成员;即上改为:
p->m(); //OK,p a pointer to an object

17.在static成员函数中使用this时错误的。

四、继承

1.使用using声明可以改变成员在派生类中的访问限制,如:

//基类中的共有成员一般情况下被继承为共有成员,但使用using声明可将其改为私有成员(或保护成员)
class BC {
public:
    void set_x(float a) {x=a;}
private:
    float x;
};
class DC : public BC {
 public:
    void set_y ( float b ) { y = b;}
private:
    float y;
    using BC::set_x;
};
//这样的话,无法直接通过DC类的任何对象调用set_x

2.定义简单派生类构造函数的一般形式:
<派生类构造函数名>(<总参数列表>):<基类构造函数名>(<参数表>)
{ <派生类新增数据成员初始化> };
在建立一个对象时,执行构造函数的顺序是:
1)最先调用基类的构造函数,对基类数据成员初始化;对基类的构造函数的调用顺序取决于这些基类在被继承时的说明顺序,于他么的初始化列表给出的顺序无关;
2)再调用数据成员是类对象的构造函数,其调用次序按在类中定义的先后次序;
3)最后执行派生类构造函数的函数体,对派生类新增数据成员初始化。 ————先父母、后客人、最后自己——————

3.继承下的析构函数。
- 和构造函数一样,基类的析构函数派生类也不能继承;
- 在声明派生类时,可以根据需要定义自己的析构函数,用来对派生类中新增加的成员进行清理工作;
- 在执行派生类的析构函数时,系统会自动调用基类的析构函数,对基类进行清理;
- 派生类析构函数的执行顺序于构造函数正好相反(原因:析构函数时用来释放由构造函数分配的内存资源,这种次序,可以确保最近分配的额内存资源可以最先被释放)
4.多继承

  • 单继承基类和派生类组成树结构,而多继承基类和派生类组成有向图结构;多继承的派生类可以同时具有多个基类,它同时继承了这些基类的所有成员;
  • 派生类构造函数执行顺序是先执行所有基类的构造函数,再执行派生类本身构造函数,在多继承情况下,基类构造函数的执行顺序按它们在被继承时所声明的顺序(从左到右)一次调用,与它们在初始化列表中的顺序无关。
  • 基类的构造函数被先调用(按声明时的顺序),数据成员所在类的构造函数次之,最后执行派生类的构造函数。
  • 多继承机制下的命名冲突。

(转)

虚函数

定义一个函数为虚函数,不代表函数为不被实现的函数。
定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。
定义一个函数为纯虚函数,才代表函数没有被实现。
定义纯虚函数是为了实现一个接口,起到一个规范的作用,规范继承这个类的程序员必须实现这个函数。
1、简介
假设我们有下面的类层次:

class A  
{  
public:  
    virtual void foo()  
    {  
        cout<<"A::foo() is called"<<endl;  
    }  
};  
class B:public A  
{  
public:  
    void foo()  
    {  
        cout<<"B::foo() is called"<<endl;  
    }  
};  
int main(void)  
{  
    A *a = new B();  
    a->foo();   // 在这里,a虽然是指向A的指针,但是被调用的函数(foo)却是B的!  
    return 0;  
}  

这个例子是虚函数的一个典型应用,通过这个例子,也许你就对虚函数有了一些概念。它虚就虚在所谓“推迟联编”或者“动态联编”上,一个类函数的调用并不是在编译时刻被确定的,而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数,所以被成为“虚”函数。
虚函数只能借助于指针或者引用来达到多态的效果。
C++纯虚函数
一、定义
 纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”
 virtual void funtion1()=0
二、引入原因
  1、为了方便使用多态特性,我们常常需要在基类中定义虚拟函数。
  2、在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。
  为了解决上述问题,引入了纯虚函数的概念,将函数定义为纯虚函数(方法:virtual ReturnType Function()= 0;),则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类,它不能生成对象。这样就很好地解决了上述两个问题。
声明了纯虚函数的类是一个抽象类。所以,用户不能创建类的实例,只能创建它的派生类的实例。
纯虚函数最显著的特征是:它们必须在继承类中重新声明函数(不要后面的=0,否则该派生类也不能实例化),而且它们在抽象类中往往没有定义。
定义纯虚函数的目的在于,使派生类仅仅只是继承函数的接口。
纯虚函数的意义,让所有的类对象(主要是派生类对象)都可以执行纯虚函数的动作,但类无法为纯虚函数提供一个合理的缺省实现。所以类纯虚函数的声明就是在告诉子类的设计者,“你必须提供一个纯虚函数的实现,但我不知道你会怎样实现它”。

抽象类的介绍
抽象类是一种特殊的类,它是为了抽象和设计的目的为建立的,它处于继承层次结构的较上层。
(1)抽象类的定义: 称带有纯虚函数的类为抽象类。
(2)抽象类的作用:
抽象类的主要作用是将有关的操作作为结果接口组织在一个继承层次结构中,由它来为派生类提供一个公共的根,派生类将具体实现在其基类中作为接口的操作。所以派生类实际上刻画了一组子类的操作接口的通用语义,这些语义也传给子类,子类可以具体实现这些语义,也可以再将这些语义传给自己的子类。
(3)使用抽象类时注意:
• 抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出。如果派生类中没有重新定义纯虚函数,而只是继承基类的纯虚函数,则这个派生类仍然还是一个抽象类。如果派生类中给出了基类纯虚函数的实现,则该派生类就不再是抽象类了,它是一个可以建立对象的具体的类。
• 抽象类是不能定义对象的。

总结:
1、纯虚函数声明如下: virtual void funtion1()=0; 纯虚函数一定没有定义,纯虚函数用来规范派生类的行为,即接口。包含纯虚函数的类是抽象类,抽象类不能定义实例,但可以声明指向实现该抽象类的具体类的指针或引用。
2、虚函数声明如下:virtual ReturnType FunctionName(Parameter);虚函数必须实现,如果不实现,编译器将报错,错误提示为:
error LNK****: unresolved external symbol "public: virtual void __thiscall ClassName::virtualFunctionName(void)"
3、对于虚函数来说,父类和子类都有各自的版本。由多态方式调用的时候动态绑定。
4、实现了纯虚函数的子类,该纯虚函数在子类中就编程了虚函数,子类的子类即孙子类可以覆盖该虚函数,由多态方式调用的时候动态绑定。
5、虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。
6、在有动态分配堆上内存的时候,析构函数必须是虚函数,但没有必要是纯虚的。
7、友元不是成员函数,只有成员函数才可以是虚拟的,因此友元不能是虚拟函数。但可以通过让友元函数调用虚拟成员函数来解决友元的虚拟问题。
8、析构函数应当是虚函数,将调用相应对象类型的析构函数,因此,如果指针指向的是子类对象,将调用子类的析构函数,然后自动调用基类的析构函数。

有纯虚函数的类是抽象类,不能生成对象,只能派生。他派生的类的纯虚函数没有被改写,那么,它的派生类还是个抽象类。
定义纯虚函数就是为了让基类不可实例化化
因为实例化这样的抽象数据结构本身并没有意义。
或者给出实现也没有意义
实际上我个人认为纯虚函数的引入,是出于两个目的
1、为了安全,因为避免任何需要明确但是因为不小心而导致的未知的结果,提醒子类去做应做的实现。
2、为了效率,不是程序执行的效率,而是为了编码的效率。

推荐阅读更多精彩内容