C++基础

今天看了孙鑫的C++第二课，了解了C++的一些基本知识

1. struct 结构关键字

  在 C++ 中的结构类型和 C 一样，是用 struct 定义的

  struct  结构名
  {
     int i;
     int j;
     void fun()
     {
        cout<<"这里结构中的一个函数"<<endl;
     }
  };          -> 这里

  首先，结构是 struct 开始 以 " ；" 号结尾 ,  与 c 不同的是 C++ 中的结构类型

可以定义函数 , 如上所示   void fun() 这个函数。
 
  其次，结构中默认的访问类型为 public,每个一结构中有一个隐藏的 public
 
struct  结构名
  {
   public:                         -> 这里显示指示
     int i;
     int j;
     void fun()
     {
        cout<<"这里结构中的一个函数"<<endl;
     }
  };          -> 这里

同样，我们也可以以 private 来指示访问属性

struct  结构名
  {
  private:
     int i;
     int j;
     void fun()
     {
        cout<<"这里结构中的一个函数"<<endl;
     }
  };          -> 这里

这样，当我再声明一个结构类型变量时，将不能访问 i,j 这两个值 ，因为他们是私有的

由此想到 delphi 中结构(记录类型)的定义

在 delphi 中，这种定义方式叫记录类型

type
  record  结构/记录名
    i:integer;
    s:string;
  end;

下面是 delphi 联机帮助中的例子

type
  TPoint = record
    X, Y: Single;
  end;                  -> 定义了一个结构

  TVector = array[0..1] of TPoint;                   -> 定义了一个数组
  TMonth = (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);       -> 集合类型
  TDate = record
    D: 1..31;
    M: TMonth;
    Y: 1900..1999;
  end;
const
  Origin: TPoint = (X: 0.0; Y: 0.0);                             -> 常量
  Line: TVector = ((X: -3.1; Y: 1.5), (X: 5.8; Y: 3.0));
  SomeDay: TDate = (D: 2; M: Dec; Y: 1960);

 

2 . 类 Class 的定义

 类的定义和 struct 的定义很相似

 class  类名
  {
     int i;
     int j;
     void fun()
     {
        cout<<"这里结构中的一个函数"<<endl;
     }
  };          -> 这里

类以 class 开始 以 " ；" 结束

在 类中，默认的访问为 private 

在类中有三种访问权限   public ,private ,protected

public    是公有的，没有限制
private          是私有的，只有本类才可以访问
protected        保护的，子类可以访问

这三种访问限制符和 delphi 中的一样

说到类，就会想到 构造方法和析构方法

C++中的构造方法和析构方法的定义

   构造方法是  和类名一样,但不可以有返回值

   析构方法是  ~加上类名,也不可以有返回值，还不可以带参数
 
   C++ 中一定要有构造方法，要是不写则编译器会给你指定一个默认的无参数的构造方法
  
例:

class Animal
{
public:
 Animal(int height,int weight)
 {
  cout<<"animal construct"<<endl;
 }
 ~Animal()
 {
  cout<<"animal destructor"<<endl;
 }
};

上面的例子的构造方法带了参数

要想继承 Animal 这个类，则定义方法为

如:
 
  class Fish: public Animal
  {
  };

注意一下  上面的 public  还可以替换为 private ,protected

这里的意思是子类对父类里变量的访问权限

public  没有变化，父类中的变量或函数的访问权限是什么则还是什么

private 父类中的所有的都为 private

protected  父类中 public 变为 protected ，而 protected 变为 private

对于 父类的 private 则还是 private

如果子类的构造函数没有参数，则父类有参数，则子类要显示调用父类的构造函数

例

#include <iostream.h>
class Animal
{
public:
 Animal(int height,int weight)
 {
  cout<<"animal construct"<<endl;
 }
 ~Animal()
 {
  cout<<"animal destructor"<<endl;
 }
 void eat()
 {
  cout<<"animal eat"<<endl;

 }
 void sleep()
 {
  cout<<"animal sleep"<<endl;

 }
protected:
 void breathe()
 {
  cout<<"animal breathe"<<endl;
 }
};

class fish : protected Animal
{
public:
 fish():Animal(10,10), a(20)                         -> 这里要显示调用
 {
  cout<<"fish construct"<<endl;
  cout<<a;
 }
 ~fish()
 {
  cout<<"fish destruct"<<endl;
 }
private:
 const int a;              -> 可以动态的指定一个常量
};

void main()
{
  //Animal a;
 // a.eat();
  fish f;
  f.breathe();

}

子类和父类的构造函数以及析构函数的执行顺序是

先父类的构造，而后是子类的构造，再是子类的析构，最后是父类的析构