C++ note

主要是为了学习c++的类和对象

 

内容摘自 c++概述

http://see.xidian.edu.cn/cpp/biancheng/cpp/rumen_1/

 

1，变量 

，C++中，我们可以在函数体内声明一个静态局部变量（Static Local Variable）。它在函数运行结束后不会消失，并且只有声明它的函数中能够使用它。我们可以在函数体外声明一个变量，它称为全局变量（global variable），在某一层次声明的变量的作用域就终止于该变量所在层次的末尾。在某个函数的同一语法层次内不能声明多个名字相同的变量。在函数体内声明一个静态局部变量（Static Local Variable）。它在函数运行结束后不会消失，并且只有声明它的函数中能够使用它（static int a;）。

2，逻辑

if (m!=0 && n/m<1)，当m=0时，电脑不会去尝试用n/m了，而是直接跳过整句语句。这样，我们就能够避免除数为零的错误了

“……？……：……”称为条件操作符，它的运算优先级比逻辑或还低，是目前为止优先级最低的操作符， max=(a>=b)?a:b;

在switch语句中，我们要记住四个关键词，分别是switch、case、default和break。

switch（表达式）

{

   case 常量表达式1：

   {

      语句块1；

      break；

   }

   default：

   {

      语句块n+1；

   }

}

cout <<setw(2) <<a <<b;语句中域宽设置仅对a有效，对b无效。

3，函数

一旦函数运行结束，那么该函数中声明的参数和变量都将消失。

return 符合返回值类型的表达式；

在返回空类型的函数中可以使用return语句，人为地停止函数的运行，也可以不使用return语句，使其运行完所有语句后自然停止。

4，存储

在定义默认参数时，必须在函数声明中定义

void create(int n=100);//在函数声明中定义默认参数

int size=sizeof(array)/sizeof(int);//数组的大小

数组作为参数传递给函数的只是数组首元素的地址，函数在需要用到后面元素时再按照这个地址和数组下标去查找

指针和整数C的加减法是指针向前或向后移动C个对应类型的存储区域

数组名是指针，但它是一个指针常量。也就是说，不带下标的数组名不能作为左值。

数组的大小在编译前必须是已知的常量表达式

不同于数组，结构是按值传递的。也就是说整个结构的内容都复制给了形参，即使某些成员数据是一个数组。使用返回结构体方式实现修改

5,调试

用函数声明和定义分离的方式：把所有的声明都放在shape.h中，把所有的定义放在shape.cpp中

#开头的命令都是编译预处理命令，比如#if、#else、#endif、#ifdef、#ifndef、#undef和#define

无论这个文件是C++提供的还是自己编写的，使用#include "文件名"命令一定是正确的

如果包含头文件时写作如#include <iostream>，但是没有using namespace std;必须要使用std名字空间。

在编译阶段发生的错误称为编译错误（Compile Error），在运行阶段发生的错误称为运行时错误（Runtime Error）。对于编译错误，我们通过检查并修正语法错误来解决；对于运行时错误，我们通过检查并修正语意（程序设计思想）错误来解决

6，对象

面向对象（Object Oriented，简称OO）

对象就是任何我们可以想象出来的具体的物体

能够抽象地描述某一些具有共性的物体的词称为类（Class）

类与结构相似，它也是一种由用户自己定义的数据类型；它也可以通过成员数据来刻画一些现实生活中的东西。不同的是，对它的操作并不是通过普通的函数，而是通过类的成员函数来实现的

定义完一个类之后务必要在最后加上一个分号。

类中变量在定义或声明时不说明该成员数据（或成员函数）是公有的还是私有的，则默认为私有的。

class Node//定义一个链表结点类

{

   public:

   int idata;//数据能够被外部访问

   char cdata;//数据能够被外部访问

   private:

   Node *prior;//前驱结点的存储位置保密

   Node *next;//后继结点的存储位置保密

};

如果一个类的某个成员函数是私有的，那么它只能被这个类的其他成员函数调用。

const这个保留字来保护成员数据不被成员函数改变

成员函数的写法就是在函数的参数表后面加上一个const，比如：int readi() const;//通过该函数读取idata，但不能改变任何成员数据

"::"操作符，它表示该函数是属于某一个类的，称为域解析操作符

定义类成员函数

//node.h

class Node//定义一个链表结点类

{

   public:

   int readi() const;//通过该函数读取idata，但不能改变任何成员数据

   bool set(int i);//重载，通过该函数修改idata

   bool set(char c);// 重载，通过该函数修改cdata

   private:

   int idata;//存储数据保密

   char cdata;//存储数据保密

};//类定义结束，分号切勿忘记

int Node::readi() const   //成员函数readi的定义

{

   return idata;

}

bool Node::set(int i)//重载成员函数定义

{

   idata=i;

   return true;

}

bool Node::set(char c)

{

   cdata=c;

   return true;

}

调用成员函数

//main.cpp

#include <iostream>

#include "node.h"//包含我们编写好的链表结点类头文件，必须用双引号

using namespace std;

int main()

{

   Node a;//创建一个链表结点对象a

   a.set(1);//设置idata

   a.set('A');//设置cdata

   cout <<a.readi() <<endl;

   cout <<a.readc() <<endl;

   return 0;

}

对象的引用

   Node b;//声明一个结点对象

   Node &a=b;//声明一个引用

   a.set(0);//效果与b.set(0)相同

对象指针

   Node b;//声明一个结点对象

   Node *a=&b;//声明一个对象指针

   a->set(0);//效果与b.set(0)相同

   a->readi();//效果与b.readi()相同

对象的初始化的方法，增加初始化函数 void init（type，type）;

构造函数是一种随着对象创建而自动被调用的函数，与类同名的成员函数就是构造函数，它的主要用途是为对象作初始化，它是一个公有的成员函数，并且构造函数没有返回值类型。

class Node//定义一个链表结点类

{

   public:

   Node();//构造函数的声明，构造函数是公有的成员函数，没有返回值类型

   private:

   int idata;//存储数据保密

   char cdata;//存储数据保密

};

Node::Node() //构造函数的定义

{

   cout <<"Node constructor is running..." <<endl;//提示构造函数运行

   idata=0;//初始化idata

   cdata='0';//初始化cdata

}

带参数的构造函数（构造函数也可以重载）

Node::Node(int i,char c)//构造函数重载1，默认参数只需要在函数原型中出现

{

   cout <<"Node constructor is running..." <<endl;

   idata=i;

   cdata=c;

   prior=NULL;

   next=NULL;

}

 对应于main中的，Node b(8);//创建一个链表结点对象b，调用构造函数重载1，参数c默认为'0'

在C++中，每个类都有且必须有构造函数。如果用户没有自行编写构造函数，则C++自动提供一个无参数的构造函数，称为默认构造函数。这个默认构造函数不做任何初始化工作。一旦用户编写了构造函数，则这个无参数的默认构造函数就消失了。如果用户还希望能有一个无参数的构造函数，必须自行编写

深拷贝构造函数是真正意义上的复制了链表a，并且使得链表a和链表b各自独立，互不干扰。这才是自定义拷贝构造函数存在的重要意义

//拷贝构造  

 CExample(const CExample& C)  

 {  

  a = C.a;  

  cout<<"copy"<<endl;  

 }  

CExample B = A; // CExample B(A); 也是一样的，这里不是赋值

析构函数（Destructor）能随着对象的消亡而自动被调用

对象作为函数参数时，会先调用对象的拷贝构造函数，把参数的值复制给临时对象，函数结束后，临时对象调用析构函数

构造函数用于初始化对象，拷贝构造函数用于访问创建的对象，用于类向对象中的似有成员传递指

对象rect1的p和rect2的指针成员p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”

初始式example

#include "iostream"

#include "stdlib.h"

using namespace std;

 

class A

{

public:

A(int i,char c);

void show();

private:

int idata;

char cdata;

};

A::A(int i,char c)

{

idata=i;

cdata=c;

}

void A::show()

{

cout <<"A.show"<<endl<<idata<<endl;

cout<<cdata<<endl;

cout<<"A.show end"<<endl;

}

class B

{

public:

B(int i,char c);

void show();

private:

int bint;

A ao;

A *p;

char bchar;

};

B::B(int i,char c):ao(i,c)

{

cout<<"B copy and creat"<<endl;

cout<<i<<c<<endl;

p=&ao;

cout<<"B copy and creat end"<<endl;

 }

void B::show()

{

cout<<"B.show begin"<<endl;

p->show();//或者ao.show();

cout<<"B.show end"<<endl;

}

int main()

{

A a(1,'a');

a.show();

B b(2,'b');

b.show();

system("pause");

}

如果指针指向不是用 new 分配的内存地址，则在该指针上使用 delete 是不合法的。

const int *pci = new const int(1024);

动态创建的 const 对象必须在创建时初始化，并且一经初始化，其值就不能再修改。

由new生成的ptemp，在执行delete之后，还可以对其进行赋值操作，猜想delete 操作删除的是指针指向内存的内容

 

一个类成员中有其他类对象，可以用以下方式构造（linklist成员中有node类，pucurrent和head分别为node类的对象和对象指针

方式一

Linklist::Linklist(int i,char c):head(i,c)//类名::构造函数名(参数表):成员对象名1(参数表)，链表类构造函数，调用head对象的构造函数重载1，详见Node.h文件

{

   cout<<"Linklist constructor is running..."<<endl;

   pcurrent=&head;

}

方式二，需要在node类中声明linklist是友元类，friend class Linklist;

Linklist::Linklist(Linklist &l):head(l.head)

{

   cout<<"Linklist Deep cloner running..." <<endl;

   pcurrent=&head;

   Node * ptemp1=l.head.next;//直接访问私有成员数据

while(ptemp1!=NULL)//复制链表

   {

      Node * ptemp2=new Node(ptemp1->idata,ptemp1->cdata,pcurrent,NULL);

      pcurrent->next=ptemp2;

      pcurrent=pcurrent->next;

      ptemp1=ptemp1->next;

}

 

一个函数要访问一个或多个对象的私有成员时，我们可以用友元来解决这个问题。

friend void ShowNode(Node &n);//声明友元函数ShowNode，在节点类中声明

在main函数中可以使用ShowNode(b);//用友元函数输出b结点的内容

 

操作符重载，a是复数

void Complex::operator =(Complex a)

{

   real=a.real;

   img=a.img;

}

Complex Complex::operator +(Complex a)

{

   Complex temp(a.real+real,a.img+img);

   return temp;

}

这样在main函数中，可以进行操作

Complex a(3,2),b(5,4),c(1,1),d(4,2),temp;

   temp=a+b;

 

继承的方法，使我们可以用一种已经编写好的类来扩写成一个新的类

class 子类名：[public，private，protect]父类名；

private（私有）和protected（保护）都能实现类的封装性。private能够对外部和子类保密，即除了成员所在的类本身可以访问之外，别的都不能直接访问。protected能够对外部保密，但允许子类直接访问这些成员。

 

private是私有继承父类所有的公有、保护成员继承到子类时，类型会发生改变。父类的公有成员在子类中变成了私有成员，父类的保护成员在子类中也变成了私有成员。父类不能在访问子类中成员

 

class Stack:private Linklist//私有继承链表类

void Stack::show()

{

Show();//用Linklist类的成员函数实现功能

}

父类的成员对象是最先构造的，接着是运行父类的构造函数，最后运行子类的构造函数。

子类的构造函数的参数传递给父类的构造函数

Stack::Stack(int i,char c):Linklist(i,c)//将子类构造函数的参数传递给父类的构造函数

{

   cout <<"Stack constructor with parameter is running..." <<endl;

}

使用了继承之后，析构函数的运行顺序依然恰好与构造函数的运行顺序相反。

 

父类指针能否指向子类对象？子类指针能否指向父类对象？

在公有继承情况下父类的对象指针指向子类对象是允许的。子类的对象指针指向父类是禁止的

用父类的对象指针指向子类对象，那么这个指针无法使用子类中扩展出的成员。

 

子父类例子

如果有一个本科生对象s1和一个学生对象s2，那么显然s1.study()会是学习高等数学和大学英语，s2.study()会是随便学些什么。但是，如果有一个学生类的指针sp，它也能指向本科生对象，这时调用sp->study()会是怎么样的呢？我们发现，即使它指向一个本科生对象，它也只能“随便学些什么”。

 

不同的子类的同名成员函数有着不同的表现形式，称为多态性

多态性往往只有在使用对象指针或对象引用时才体现出来。多态性是面向对象的一个标志性特点，没有这个特点，就无法称为面向对象。

 

设置虚函数的方法为：在成员函数的声明最前面加上保留字virtual。注意，不能把virtual加到成员函数的定义之前，否则会导致编译错误。

 

virtual void study();//把学习设置为虚函数,父类中

void student::study()//成员函数定义处没有virtual

{

   cout <<"随便学些什么。" <<endl;

   return;

}

virtual void study();//把学习设置为虚函数，父类的一个子类中class Undergraduate:public student

void Undergraduate::study()//成员函数定义处没有virtual

{

   cout <<"学习高等数学和大学英语。" <<endl;

   return;

}

 virtual void study();//把学习设置为虚函数，父类的一个子类中class Pupil:public student

void Pupil::study()

{

   cout <<"学习语数外。" <<endl;

   return;

}

main函数中

 Undergraduate s1;

   student s2;

   Pupil s3;

student *sp

无论父类对象指针sp指向哪种子类对象，sp->study()的执行结果总是与对应的类相符合的

要使用虚函数实现多态性，至少要使各个函数的参数格式也完全相同。

当子类函数和父类参数不同时，会执行父类中的同名成员函数

编写成员函数的时候，可以把尽可能多的成员函数设置为虚函数。

 

给析构函数的前面加上保留字virtual， virtual ~Animal();//虚析构函数,父类animal中

子类中

Cat::~Cat()

{

   cout <<"Cat destructor is running..." <<endl;

}

main中

Animal *pa=new Cat(2,1);

   Cat *pc=new Cat(2,4);

delete pa;

   delete pc;

结果：

Cat constructor is running...

Animal consturctor is running...

Cat constructor is running...

Delete pa:

Cat destructor is running...

Animal destructor is running...

Delete pc:

Cat destructor is running...

Animal destructor is running...

子类和父类的析构函数都被执行

虚函数是为了实现多态，而虚析构函数是为了同时运行父类和子类的析构函数，使资源得以释放。

 

只能用于被继承而不能直接创建对象的类设置为抽象类（Abstract Class）。

类中的确存在，但是在父类中无法确定具体实现的成员函数称为纯虚函数。纯虚函数是一种特殊的虚函数，它只有声明，没有具体的定义。抽象类中至少存在一个纯虚函数；存在纯虚函数的类一定是抽象类。

 

设置纯虚函数之后并不影响多态的实现，但是却将父类变成了抽象类，限制了父类对象的创建，virtual void study()=0;//在父类的声明中通过代码实现，声明study为纯虚函数

 

完