C++笔记（一）——C++的基本介绍及构成

深碍√TFBOYSˉ_ 2022-05-20 10:20 190阅读 0赞

C++相比于C的优点主要体现在**封装性、继承性（Inheritance）、和多态性**。

*  1）封装性：把**数据**与操作数据的**函数**组织在一起，不仅**使程序结构更加紧凑**，并且**提高了类内部数据的安全性**；
 *  2）继承性：**增加**了软件的**可扩充性**和**代码重用性**；
 *  3）多态性：一条指令控制不同子类实现不同的功能。使设计人员在设计程序时可以对问题进行更好的抽象，**有利于代码的维护和可重用。**[C++笔记（八）——类4：多态   https://mp.csdn.net/postedit/83012495][C_4_ _https_mp.csdn.net_postedit_83012495]

# 一、C++构成 #

## 1.1 头文件 ##

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>#include &lt;iostream&gt; &nbsp;//后不加分号</p> </td> 
  </tr> 
 </tbody> 
</table>

\#include是**预处理器指示符**，将后面**< >**或者**“ ”**中的内容读入我们的文本文件中。

iostream是**输入\\输出流库标准文件**（注意其**没有后缀**），它包含cout信息

预处理器部分的详细说明见链接：

[https://blog.csdn.net/qq\_37764129/article/details/82904970][https_blog.csdn.net_qq_37764129_article_details_82904970]

## 1.2 命名空间 ##

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>using namespace std; //使用了std标准的命名空间（这个命名空间中定义很多的标准定义）</td> 
  </tr> 
 </tbody> 
</table>

这条语句被称为using指示符，C++标准库中的名字都是在一个称作std的名字空间中声明的

[https://blog.csdn.net/qq\_37764129/article/details/81202954][https_blog.csdn.net_qq_37764129_article_details_81202954]

## 1.3 主函数 ##

![70][]

int main （int a ，void b）//函数原型包括：返回值类型，函数名，参数表
    {
        int num; //变量声明
        num = 3; //赋值
    
        cout << "The num is" << num; //输出
        
        return 0; //提供了终止函数的一种方法
    }  //中括号的部分属于函数体

函数：[https://mp.csdn.net/postedit/81609567][https_mp.csdn.net_postedit_81609567]

C++标准库还提供了一组扩展的基本数据类型，其中包括字符串（string）、复数（complex number）、向量（vector）和列表（list）。例如：

//为了使用string对象，下面的头文件是必须的
    #include <string>
    string current_chapter = "Getting Started";
    
    //为了使用vector对象，下面的头文件是必须的
    #include <vector>
    vector <string> chapter_titles(20);

string current\_chapter 是一个字符串对象，被初始化为字符串文字"Getting Started"。chapter\_titles是一个包含有20个字符串类型的元素的向量。还有一种写法：

vector <string> //指示编译器创建一个能够存放字符串元素的向量类型。
    vector <int> ivec(20); //定义一个能够存放20个整数的向量对象。

### 1.3.1 作用域和作用域运算符“::” ###

作用域：**变量**在程序中的**起作用范围。**分为全局作用域、局部作用域、语句作用域

优先级：范围越小优先级越高

作用域运算符：**“::”**

如果希望在**局部变量的作用域内**使用**同名的全局变量**，可以在该变量前加上“::”，“::”称为作用域运算符

#include <iostream>
    
    using namespace std;
    
    int num = 10;//全局变量
    int main( )  //函数原型
    { 
    	int num = 20;//局部变量
    	
    	cout << "num = " << num << endl; //输出局部变量的值
    	cout << "num0 = " << ::num << endl; //"::num"表示输出全局变量的值
    
    	system("pause");//防止运行结果闪退，也可用getchar();
    	return 0;
    }

作用域：[https://mp.csdn.net/postedit/81778331][https_mp.csdn.net_postedit_81778331]

## 1.3.2输入输出 ##

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>输入：</p> <p><span style="color:#86ca5e;">“&gt;&gt;”：右移操作符</span></p> <p><span style="color:#86ca5e;">cin：标准输入，代表键盘</span></p> <p>cin &gt;&gt; i; <span style="color:#86ca5e;">//在键盘上输入i的值</span></p> </td> 
  </tr> 
  <tr> 
   <td> <p>输出：</p> <p style="margin-left:0pt;"><span style="color:#00b050;">“&lt;&lt;”：左移操作符，在C++里面表示功能的改造（增强）==&gt;C++ 语言操作符重载</span></p> <p style="margin-left:0pt;"><span style="color:#00b050;">count：标准输出，黑屏幕</span></p> <p style="margin-left:0pt;"><span style="color:#00b050;">endl：表示换行的意思，跟C中的‘/n’功能类似</span></p> <p style="margin-left:0pt;">&nbsp; cout &lt;&lt; "i = " &lt;&lt; i &lt;&lt; endl; <span style="color:#86ca5e;">//打印到屏幕，并且回车换行</span></p> </td> 
  </tr> 
 </tbody> 
</table>

换行符有两种：

1）双字符序列“***\\n***”表示换行符（newline）：常用在要是显示的字符串后面；

2）使用预定义的iostream操作符***endl***。

操作符endl在iostream上执行的是一个操作，而不只是简单地提供数据。例如：endl在输出流中插入一个换行符，然后刷新输出缓冲区。这两种换行常见的用法为：

cout << "Hello world ! \n";
    cout << "The sum of" << v1 << "+" << v2 << "=" << v1 + v2 << endl;

#include <iostream>
    using namespace std;
    
    int main()
    {
    	int array[5] = { 2, 4, 5, 6, 7 };
    	int i;
    	cout << array[3] << endl;
    	
    	for (i = 0; i < 5; i++)
    	{
    		cout << "array[" << i << "] = " << array[i] << endl;
    		cout << "-------------------------\n";
    		printf("array[%d] = %d\n", i, array[i]);
    		cout << endl;
    	}
    	system("pause");
    	return 0;
    }

输出结果：

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70][] ##

## 1.3.3 动态内存分派和指针 ##

### 内存分配 ###

在C++中，内存有两种分配方法：静态内存和动态内存，其区别主要是效率和灵活性间的平衡准则不同。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>分配方法</td> 
   <td><strong>静态分配</strong></td> 
   <td><strong>动态分配</strong></td> 
  </tr> 
  <tr> 
   <td>定义</td> 
   <td>即编译器在处理程序源码时分配</td> 
   <td>即程序执行时调用运行时刻库函数来分配</td> 
  </tr> 
  <tr> 
   <td> <p>区别</p> </td> 
   <td> <p>静态内存分配是在<strong>程序执行之<span style="color:#f33b45;">前</span>进行</strong>的，<span style="color:#f33b45;"><strong>效率高</strong></span><span style="color:#f33b45;">，</span><strong><span style="color:#f33b45;">缺少灵活性</span>。</strong>需要在程序执行前知道所需内存的<strong>类型和数量</strong></p> </td> 
   <td> <p>&nbsp;</p> <p>&nbsp;</p> </td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td> <p>静态对象是<strong>有名字的变量</strong>，我们可以<strong>直接对其操作</strong>。</p> <p><strong>eg：&nbsp; int a；</strong></p> <p><strong>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; a = 3；</strong></p> </td> 
   <td> <p>动态对象是<strong>没有名字的变量</strong>，需要<strong>通过指针间接地对它进行操作</strong>。</p> </td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td>静态对象的<strong>分配与释放</strong>由<strong>编译器自动处理。</strong></td> 
   <td>动态对象的分配与释放必须由<strong>程序员显式地管理</strong>，相对容易出错，它通过<strong>new和delete</strong>两个表达式来<strong>完成</strong></td> 
  </tr> 
 </tbody> 
</table>

对象的动态分配——new,new表达式有两个版本

1）第一个版本用于分配**特定类型的单个对象**

分配了一个没有名字的**int类型的对象**，对象初始值为1024。**表达式返回对象**在**内存中的地址**。接着，**这个地址**被用来**初始化指针对象pint**。对于**动态分配法内存**，**唯一的访问方式**是通过**指针间接地访问**。

2）第二个版本用于分配**特定类型和维数的数组**。

分配了一个含有四个整数元素的数组。可**不能给动态分配的数组的每个元素显式地指定一个初始值**。

分配动态数组时一个时常令人迷惑的问题是，返回值只是一个指针，与分配单一动态对象的返回类型相同。例如，pint与pia的不同之处在于，pia拥有四元素数组的第一个元素的地址，而pint只是简单地包含单一对象的地址。当用完了动态分配的对象或对象的数组时，我们必须显式的释放这些内存。可通过delete使用表达式的两个版本之一来完成这件事，而释放之后的内存则可以被程序重新使用。

1）单一对象的delete表达式形式如下：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>//删除单个对象</p> <p>delete pint；</p> </td> 
  </tr> 
 </tbody> 
</table>

2）数组形式的delete表达式如下：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>//删除一个对象数组</p> <p>delete [ ] pia；</p> </td> 
  </tr> 
 </tbody> 
</table>

注：如果没有删除动态分配的内存，程序结束时会出现内存泄露的问题。（内存泄露：指一块动态分配的内存，我们不在拥有指向这块内存的指针，因此我们没办法将它返还给程序供以后重新使用）

**指针**

在C++中，指针的主要用处是**管理和操纵动态分配的内存。**

指针：[https://mp.csdn.net/postedit/80609725][https_mp.csdn.net_postedit_80609725]

# 类的定义的宏观理解： #

让我们把世界看成一个由对象所组成的大环境。这里的“对象”就是“东西”，为了描述对象，我们应该先把**对象的属性**描述出来。从宏观上来说，这个“对象的属性”就是类。

## 类的封装特性： ##

把数据声明为private，**不允许外界随意存取，只能通过特定的接口来操作**，这就是面对对象的封装操作。

## 1.4 类：是一种数据类型，包含成员变量和成员函数。 ##

##       对象：即类型为类的数据变量。 ##

可以用它来定义这种类类型的对象，就像用内置的类型定义对象一样，比如

//单个IntArray类对象
    IntArray myArray;
    
    //指向IntArray类对象的指针
    IntArray *pArray = new IntArray;

1.4.1 类定义

类包括：类头和类体两部分组成。类头由关键字class与相关联的类名字构成；类体由花括号括起来，以分号结束。是定义该类实现的具体功能，包含成员定义及访问标签

1.4.2 类的成员

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td> <p>class plus &nbsp;<span style="color:#86ca5e;">//plus是类的名字，对于C++的class，所有的成员变量都是这个类私有的，不能在类的外部访问</span></p> <p>{ </p> <p>&nbsp;<strong> public：</strong><span style="color:#86ca5e;">//关键字,说明变量是共有的，可以在类的外部访问，</span></p> <p>&nbsp; &nbsp; &nbsp; int sum（）；<span style="color:#86ca5e;">//成员函数</span></p> <p>&nbsp; &nbsp; &nbsp; int x, y;<span style="color:#86ca5e;">//成员变量</span></p> <p>&nbsp; &nbsp; &nbsp; static int a；<span style="color:#86ca5e;">//静态成员变量</span></p> <p>&nbsp; <strong>private</strong>：<span style="color:#86ca5e;">//说明变量是私有的，也是C++默认类型</span></p> <p><span style="color:#86ca5e;">&nbsp;&nbsp; &nbsp; &nbsp;</span> int money;</p> <p>}；</p> <p>plus data，a；</p> </td> 
  </tr> 
  <tr> 
   <td> <p>注：</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; 1、<span style="color:#f33b45;"><strong>类和对象是1：n的关系，</strong>data和a是plus的对象，它们具有同一数据类型，但它们是独立的对象，有它们自己的数据与函数。</span></p> <p>&nbsp; &nbsp; &nbsp; &nbsp; 2、通常把<span style="color:#f33b45;">类定义</span>放在<span style="color:#e579b6;">.h头文件</span>中，<span style="color:#f33b45;">类的成员函数的定义</span>放在<span style="color:#e579b6;">.cpp源文件</span>中。</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; 3、<span style="color:#f33b45;">public</span>中的成员<span style="color:#e579b6;">多半为成员函数</span>，用于类与外界联系的界面，通过这个界面可以访问类的私有成员</p> </td> 
  </tr> 
 </tbody> 
</table>

# 类与派生类的关系:继承 #

对我们来说可以根据物体的形状把物体归为一类，比如矩形是形，椭圆形是形，三角形也是形。人们习惯把相同的性质抽取出来，成立一个类，再根据细节的不同，衍化出不同的小类，这些小类就是派生类。比如：关于形状，可以有下面的类层次结构：

![70 1][]

下图是关于职位工资的类及其派生类之间的关系，

![70 2][]

首先，这些人都是员工，所以可以把他们归到CEmployee这个大类中，其次小时工以周工时计薪，销售员是基本工资+销售提成，经理是固定周薪的形式，根据他们职位的不同，划分为不同的派生类。再根据不同的薪资计算方式的不同，判断他们之间的继承关系等。代码如下：

#include <iostream>
    
    using namespace std;
    
    /*****建立一个员工薪资体系，包括职位、名字、薪资记录方法*****/
    class CEmployee  //职员
    {
    public:
    	CEmployee();
    	CEmployee(const char* nm)
    	{
    		strcpy(m_name, nm);
    		cout << "名字：" << m_name << endl;
    	}
    private:
    	char m_name[30];
    };
    //————————————————————————————————————
    class CWage : public CEmployee //小时工；需要知道他的名字、工时m_hours，时薪m_wage
    {
    public:
    	CWage(const char* nm) : CEmployee(nm)
    	{
    		m_wage = 250.0;//时薪
    		m_hours = 40.0;//工时
    		cout << "wage: " << m_wage << endl << "hours: " << m_hours << endl;
    	}
    
    	void setWage(float wg) //成员函数
    	{
    		m_wage = wg;
    	}
    	void setHours(float hrs)
    	{
    		m_hours = hrs;
    	}
    	float computePay() 
    	{ 
    		float sale = m_hours * m_wage;
    		cout << "BasicMoney: " << sale << endl;
    		return sale;
    	}//计薪
    
    private:
    	float m_wage; //时薪
    	float m_hours; //工作时间
    };
    
    class CSales : public CWage //销售员：按时计薪，姓名。时薪、时间、销售数量、单件提成额
    {
    public:
    	CSales(const char *nm) : CWage(nm)
    	{
    		m_comm = 200.0;
    		m_sale = 5.0;
    		cout << "comm: " << m_comm << endl << "sale: " << m_sale << endl;
    	}
    	void setCommission(float comm) { m_comm = comm; }
    	void setSale(float sale) { m_sale = sale; }
    	float computePay();//计薪
    
    private:
    	float m_comm; //单件提成额
    	float m_sale; //销售数量
    
    };
    float CSales::computePay()
    {
    	float Sales_Money = CWage::computePay() + m_comm * m_sale;
    	cout << "SalesMoney: " << Sales_Money << endl;
    	return Sales_Money;
    }
    
    class CManager : public CEmployee
    {
    public:
    	CManager(const char* nm) : CEmployee(nm)
    	{
    		m_salary = 15000.0;
    		cout << "salary: " << m_salary << endl;
    	}
    	void setSalary(float salary) { m_salary = salary; }
    	float computePay();//计薪
    private:
    	float m_salary;
    };
    
    int main()
    {
    	CWage aWager("BoBO");
    	aWager.CWage::computePay();//对象aWage调用CWage类中的computePay()成员函数
    
    	CSales aSales("小米");
    	aSales.CSales::computePay();
    
    	CManager aManager("陈美静");
    
    	getchar();
    	return 0;
    }

![70 3][]

类的详细介绍：[https://blog.csdn.net/qq\_37764129/article/details/83141182][https_blog.csdn.net_qq_37764129_article_details_83141182]

# 三、实现方法：面向过程和面向对象 #

## 3.1 面向过程的编程方法：c语言为主 ##

#include “iosteram"
    
    using namespace std; //命名空间
    
    int main()
    {
        cout << "hello world" << endl; //cout：标准输出
        system("pause"); //防止运行结果很快消失。也可以用getchar();
    }

## **3.2 面向对象的编程方法:c++** ##

1、进行类的抽象。即成员变量和成员函数。注：类是一个数组类型，即固定大小内存块的别名。这是一个抽象的概念，系统不会给它分配内存。只有在定义类里面的变量（比如c1，c2）时，才会分配内存。

2、进行实例化。对类的对象进行实例化

3、定义相关功能函数。求面积。

a. 面向**过程**加工的是一个一个的**函数，顺序执行函数**

b.面向**对象**加工的是一个一个的**类，即来回的调用改变函数**

4、main集成测试

**思考：类的调用过程，对执行过程进行分析。**

class MyCircle //1.类的抽象
    {
    public:
        double m_s;
        double m_r;
    
    public:
        void setR(double r)
        {
            m_r = r;
        }
    
        double getR( )
        {
            return m_r ;
        }
    
        double getS()
        {
            m_s = 3.14 * m_r * m_r;
            return m_s;
        }
    };
    
    int main()//用面向对象的方法求圆的面积
    {
        MyCircle c1, c2;//2.对类的对象进行实例化
       double r;
        cout << "please input r:" ;
        cin >> r;
        c1.setR(r);
        cout << "the area of s =" << c1.getS( ) << endl;
        return 0;
    }

[C_4_ _https_mp.csdn.net_postedit_83012495]: https://mp.csdn.net/postedit/83012495
[https_blog.csdn.net_qq_37764129_article_details_82904970]: https://blog.csdn.net/qq_37764129/article/details/82904970
[https_blog.csdn.net_qq_37764129_article_details_81202954]: https://blog.csdn.net/qq_37764129/article/details/81202954
[70]: /images/20220520/1ba90240c88546259c3606d668290fd9.png
[https_mp.csdn.net_postedit_81609567]: https://mp.csdn.net/postedit/81609567
[https_mp.csdn.net_postedit_81778331]: https://mp.csdn.net/postedit/81778331
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70]: /images/20220520/1207d11523214a42942fcfcaa0e6418e.png
[https_mp.csdn.net_postedit_80609725]: https://mp.csdn.net/postedit/80609725
[70 1]: /images/20220520/5552eb3e9ca74c71869d0c0844446e0d.png
[70 2]: /images/20220520/75b5f7a1fc4f49b68636dcca95c4741b.png
[70 3]: /images/20220520/9c07fe7521d5430a827b379fabd78869.png
[https_blog.csdn.net_qq_37764129_article_details_83141182]: https://blog.csdn.net/qq_37764129/article/details/83141182