本文共 5920 字，大约阅读时间需要 19 分钟。

C++学习笔记

一、基础知识

1.C++的头文件为：

#include 
   
    	using namespace std;
   

2.输入语句与输出语句：

cout<<"请输入A的数值："<
   
    >A;
   

3.输入语句cin>>

• 一次读入多个数据

cin>>A>>B>>C>>D;	//输入时ABCD用空格/TAB/ENTER隔开	//结束输入必须使用ENTER

• 清理缓存区

cin.clear();//更改cin的状态标识符	cin.sync();//清除缓存区的数据流	//二者必须联合使用

Tips

先看例子：

int A;double B;char C;	cin>>A>>B>>C;	//input:2.3 4 w	//output:a=2 b=0.3 c=4

如何避免这样的问题呢？

通过清理缓存区命令可以避免：

cin>>a;		cin.clear();		cin.sync();	cin>>b;		cin.clear();		cin.sync();	cin>>c;		cin.clear();		cin.sync();

每次在执行输入时，都会清理缓存区，避免了读入数据时出现错误

4.输出语句cout<<

• 控制输出精度的函数库iomanip

#inlcude 
   

功能1：有效数字

cout<
   
    <<12.345678;	//output:12.3	//保留有效数字3位
   

功能2：保留小数点

cout<
   
    <
    
     <<12.345678;	//output:12.345	//保留小数点后3位
    
   

功能3：设置输出宽度

cout<
   
    <<6<<12<
   

• cout函数读取顺序

如下面例子：

int a = 4;	cout<<
    
     <
    

为什么不是45呢？原因在于：cout将数据读入缓存区时，从右向左读入，而输出到屏幕是从左向右输出的，cout先读入a++，为5，再读入a，为4，此时缓存区中存着：5 4，这时输出，就会输出54

可以通过改写代码避免：

int a = 4;	cout<<

二、类

类定义实例

#include 
   
    	#include 
    
     	using namespace std;		class Stu	{		pravite:		char number[8];		float Grade;		public:		void set();		void display();	};	void Stu::set(char n[8])	{		strcpy(n,number);	}	void Stu::display(){		G = Grade;		cout<
     
      <
      
       set("19211388",99);		s1->display();				(*s1).set("19211388",99);		(*s1).display();		//以上三种达到的效果是一样的				return 0;	}
      
     
    
   

本例中，由class定义的Stu就为类，系统不为其分配空间，由Stu定义的s与指针*\s1就是对象，系统会为其分配空间，可以将二者关系理解为数据类型与变量的关系。

类中包含一类事物的属性与行为，本例中，Stu的属性为private下的学号number、成绩Grade，行为包括public下的set()与display()函数，其中private中的数据不能由外部直接调用，而只能由public中自身的成员函数调用。

s.number = "19211388";  s.Grade = "100";

上述操作都是无效的，只能通过public成员函数调用数据：

Stu s;  s.set("19211388",100);  s.display();

对象的四种访问方式

Stu s,*s1;	s.set();	s.Stu::set();	s1 = new Stu;//指针初始化	s1->set();	(*s1)->set();

构造函数与析构函数

1.构造函数

• 是类的一个特殊成员函数，创建对象时需要调用该函数，在创建对象时，由系统自动调用，用户不能调用。
• 函数名与类名相同，可以带参数，但是不能指定函数返回值类型。
  **注意：**可以定义参数类型/个数不同的构造函数，即构造函数允许重载
  若用户没定义过构造函数，系统会自动生成缺省的构造函数

• 缺省构造函数：

   <构造函数名>
    (参数)	{}
   

2.拷贝构造函数

系统隐含定义的另外一个特殊的缺省构造函数，只有一个参数，能实现：

- 引用已有的对象数据来定义一个新对象。 - 做函数的形参及返回值时创建对象

Circle(Circle &c)	{		x=c.x;y=c.y;r=c.r;	}

可以用外部数据来初始化数据成员

Circle c1(0,0,2),c2(c1);	//用c1初始化c2，在创建c2时，系统会自动调用拷贝构造函数创建c2

3.构造函数案例

#include 
   
    	using namespace std;	class Complex	{		private:    	int real,img;		public:    	Complex()				//由于已经定义了析构函数，缺省析构函数就需要单独定义出来    	{}    	Complex(int r,int i)	//自己定义的析构函数    	{        	real = r;        	img = i;    	}    	void Display()    	{        	cout<
    
     =0)			//如果虚部大于零，需要补上'+'        	{            	cout<<'+';        	}        cout<
     <<'i'<
    
   

4.析构函数

当对象的生存期结束时，通过析构函数释放对象

• 当一个对象被定义在函数体内，当该函数结束时，该对象的析构函数会自动被调用，对象占用的空间被释放。
• 若一个对象的是使用new运算符被动态创建的，则在执行delete运算时，析构函数会被自动调用，该对象占用的空间被释放。
• 可以由系统自动调用，也可以由用户调用
• 函数名与类名相同，但为作区分，在名前加~
• 不可重载，一个类只能定义一个析构函数
• 析构函数不能带参数
• 缺省析构函数：

~
   <函数名>
    ()	{}
   

类的特殊成员

1.常成员

为了保护数据与对象不被更改，可将其声明为常数据成员或常对象。

• 针对常成员的操作需要通过常成员函数const实现
• 如何定义常成员：

class Circle	{		private:			double r;			const double pi;		public:			Circle(double r1,double p):pi(p)	//通过初始化列表的方式，在函数体外部初始化			{				r = r1;			}		}

2.常成员函数

常成员函数不能修改数据成员的值，相当于一种“只读”函数，用于读取常对象的值。

类型说明符 函数名(形参表) const

• 不修改对象数据成员的成员函数才能声明为常成员函数；
• 构造函数与析构函数不能声明为const；
• 只有构造函数、析构函数、常成员函数可以操作常对象；

常成员函数的一个例子

#include 
   
    using namespace std;class Time{private:    int hour,minuate,second;public:    Time()    {    }    Time(int h,int m,int s)    {        hour = h;minuate = m;second = s;    }    void setTime(int h,int m,int s)					//此处不能加const，原因是函数对数据做了修改    {        hour = h;minuate = m;second = s;    }    void print()const								//只读取数据，无修改数据，可声明为常函数    {        cout<
    
     <<":"<
     
      <<":"<
      
       <
       
        >h>>m>>s;    t1.setTime(h,m,s);    t1.print();    t2.print();    return 0;}
       
      
     
    
   

3.静态成员

定义时，需要在前面加关键字static说明。

• 静态成员是类的成员，在内存中只存贮一次，被所有对象共享；

• 初始化语句前不加static和访问权限修饰符

  初始化方式：

数据类型 类名::静态数据成员 = 值		//静态数据成员是作用在类上的一个类的成员

4.静态成员函数

一个例子：

#include 
   
    using namespace std;class Test{private:    int i;    static int k;				//定义静态数据成员public:    Test(int i1)    {        i = i1; k++;    }    void display()    {        cout<
    <
   

第一次创建对象时，静态成员k被初始化为0，而执行构造函数，需要进行k++。在生成A时，k++，在创建B时，k++，最终输出k值为2

• 不同的对象可以共享一个静态数据

三、继承与派生

1.继承关系与派生

通过继承机制，可以从现有类派生出新的类，原有类成为基类或父类，新的类称为派生类或子类。C++支持单继承与多继承

单继承

指一个派生类只有一个父类的继承关系，派生类定义形式：

class 派生类名 : 继承方式 基类名	{派生类新定义成员};

• 继承方式分为public公有继承、private私有继承、protected保护继承;

• 派生类继承基类中除构造函数与析构函数以外的所有成员;

  单继承的一个例子：

  #include 
       
        using namespace std;class Circle						//定义基类{private:    double r;public:    void set(double r1)    {        r = r1;    }    void print()    {        cout<<"半径："<
        
         <
        
       

  • 基类中的私有成员是派生类中不能访问的成员，必须通过基类public中的成员函数间接访问；

  • 如果派生类新增与基类同名的成员，则派生类将覆盖基类中的同名成员。如需使用基类中的同名成员，则需要：

    基类名::数据成员名;	基类名::成员函数名(参数表);

2.派生类对基类的访问

前面提到，派生类不能直接访问基类中的私有成员，所以必须通过在基类中定义一个获取该私有成员数据的公有函数，**通过这个公有函数间接访问私有成员的值。**```	C++class Circle{private:    double r;public:    double getr()				//定义一个读取私有成员数据的接口函数    {        return r;    }};class Cylinder:public Circle{private:    double h;public:    double volume()				//求圆柱体体积    {        double r=getr();		//通过调用接口函数给临时变量r赋值        return (3.14*r*r*h);	//需要注意的是，此处的r不是基类中的数据成员，而是临时变量r    }};```#### 构造函数与析构函数

一个例子：

#include
   
    #include
    
     using namespace std;class Staff{private:    char no[7];       				  //工号    float wage;       				  //工资public:    void display()    {        cout<
     
      <<":"<
      
       <
      
     
    
   

由本例可以看到，派生类构造函数的定义：

Staff1(char n[],float w,int t):Staff(n,w)	//总参数包括基类中的no[] wage 也包括派生类中的wt    {									//随后将基类对应的参数n w分别传给基类构造函数        cout<<"派生类构造函数被调用\n";        wt = t;    }

实质为：

派生类名(总参数表):基类构造函数(参数表1)	{派生类中数据成员初始化}

• 基类中若有缺省的构造函数或没定义构造函数，则派生类构造函数的定义中可省略对基类构造函数的调用
• ​ 基类构造函数中，只有有参的构造函数，则派生类构造函数中必须调用基类构造函数
• 派生类构造函数的调用顺序是：先基类，后派生类
• 派生类析构函数的执行顺序是：先派生类，后基类

3.基于虚函数的多态性

向不同的对象发送同一个消息，不同的对象产生不同的响应。在程序中发出消息代表调用函数，而响应代表函数实现，通过多态性可以实现“一个接口，多种方法”。

• 虚函数：
  若一个父类派生出的不同子类中都有与父类同名的成员函数，那么为了实现“一个借口，多种方法”的接口重用，则需要虚函数的支持，即：在函数类型前加visual关键字。

virtual 类型说明符 函数名 (参数表)

虚函数程序可在运行阶段具体决定调用哪个类的方法，而非按照编译阶段绑定的基类方法执行，这称为动态联编。

---

1. 实际应用中都采用公有继承，私有继承与保护继承仅在理论层面讨论

转载地址：http://rcugf.baihongyu.com/