Day9.C++基础

野性酷女 2022-08-01 11:23 140阅读 0赞

# 1程序设计方法的发展历程 #

<table> 
 <tbody> 
 <tr> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 程序设计方法的发展历程 </td> 
 </tr> 
 <tr> 
 <td> ——面向过程的结构化程序设计方法 </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 设计思路 –&nbsp; 自顶向下、逐步求精。采用模块分解与功能抽象，自顶向下、分而治之。 l&nbsp; 程序结构： –&nbsp; 按功能划分为若干个基本模块，形成一个树状结构。 –&nbsp; 各模块间的关系尽可能简单，功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成。 –&nbsp; 其模块化实现的具体方法是使用子程序。 l&nbsp; 优点： 有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 缺点：可重用性差、数据安全性差、难以开发大型软件和图形界面的应用软件 –&nbsp; 把数据和处理数据的过程分离为相互独立的实体。 –&nbsp; 当数据结构改变时，所有相关的处理过程都要进行相应的修改。 –&nbsp; 每一种相对于老问题的新方法都要带来额外的开销。 –&nbsp; 图形用户界面的应用程序，很难用过程来描述和实现，开发和维护也都很困难。 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 程序设计方法的发展历程 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ——面向对象的方法 </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 将数据及对数据的操作方法封装在一起，作为一个相互依存、不可分离的整体——对象。 l&nbsp; 对同类型对象抽象出其共性，形成类。 l&nbsp; 类通过一个简单的外部接口，与外界发生关系。 l&nbsp; 对象与对象之间通过消息进行通信。 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 优点： –&nbsp; 程序模块间的关系更为简单，程序模块的独立性、数据的安全性就有了良好的保障。 –&nbsp; 通过继承与多态性，可以大大提高程序的可重用性，使得软件的开发和维护都更为方便。 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 面向对象的基本概念 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ——对象 </td> 
 </tr> 
 <tr> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 一般意义上的对象： –&nbsp; 是现实世界中一个实际存在的事物。 –&nbsp; 可以是有形的（比如一辆汽车），也可以是无形的（比如一项计划）。 –&nbsp; 是构成世界的一个独立单位，具有 l&nbsp; 静态特征：可以用某种数据来描述 l&nbsp; 动态特征：对象所表现的行为或具有的功能 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 面向对象方法中的对象： l&nbsp; 是系统中用来描述客观事物的一个实体，它是用来构成系统的一个基本单位。对象由一组属性和一组行为构成。 l&nbsp; 属性：用来描述对象静态特征的数据项。 l&nbsp; 行为：用来描述对象动态特征的操作序列。 l&nbsp; &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 面向对象的基本概念 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ——类 l&nbsp; 分类——人类通常的思维方法 l&nbsp; 分类所依据的原则——抽象 –&nbsp; 忽略事物的非本质特征，只注意那些与当前目标有关的本质特征，从而找出事物的共性，把具有共同性质的事物划分为一类，得出一个抽象的概念。 –&nbsp; 例如，石头、树木、汽车、房屋等都是人们在长期的生产和生活实践中抽象出的概念。 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 面向对象方法中的"类" –&nbsp; 具有相同属性和服务的一组对象的集合 –&nbsp; 为属于该类的全部对象提供了抽象的描述，包括属性和行为两个主要部分。 –&nbsp; 类与对象的关系： 犹如模具与铸件之间的关系，一个属于某类的对象称为该类的一个实例。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; </td> 
 </tr> 
 <tr> 
 <td> 面向对象的基本概念 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ——封装 </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 把对象的属性和服务结合成一个独立的系统单元。 l&nbsp; 尽可能隐蔽对象的内部细节。对外形成一个边界（或者说一道屏障），只保留有限的对外接口使之与外部发生联系。 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 面向对象的基本概念 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ——封装 </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 把对象的属性和服务结合成一个独立的系统单元。 l&nbsp; 尽可能隐蔽对象的内部细节。对外形成一个边界（或者说一道屏障），只保留有限的对外接口使之与外部发生联系。 l&nbsp; 继承对于软件复用有着重要意义，是面向对象技术能够提高软件开发效率的重要原因之一。 l&nbsp; 定义：特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。 l&nbsp; 例如：将轮船作为一个一般类，客轮便是一个特殊类。 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 面向对象的基本概念 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ——多态性 </td> 
 </tr> 
 <tr> 
 <td> l&nbsp; 多态是指在一般类中定义的属性或行为，被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在一般类及其各个特殊类中具有不同的语义。 </td> 
 </tr> 
 <tr> 
 <td> 面向对象的软件工程 l&nbsp; 面向对象的软件工程是面向对象方法在软件工程领域的全面应用。它包括: –&nbsp; 面向对象的分析（OOA） –&nbsp; 面向对象的设计（OOD） –&nbsp; 面向对象的编程（OOP） –&nbsp; 面向对象的测试（OOT） –&nbsp; 面向对象的软件维护（OOSM） &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 总结： 面向过程程序设计：数据结构 + 算法 主要解决科学计算问题，用户需求简单而固定 特点： 分析解决问题所需要的步骤 利用函数实现各个步骤 依次调用函数解决问题 问题： 软件可重用性差 软件可维护性差 构建的软件无法满足用户需求 </td> 
 </tr> 
 <tr> 
 <td> 面向对象程序设计：由现实世界建立软件模型 将现实世界中的事物直接映射到程序中，可直接满足用户需求 特点： 直接分析用户需求中涉及的各个实体 在代码中描述现实世界中的实体 在代码中关联各个实体协同工作解决问题 优势： 构建的软件能够适应用户需求的不断变化 直接利用面向过程方法的优势而避开其劣势 </td> 
 </tr> 
 </tbody> 
</table>

# 2 C语言和C++语言关系 #

<table> 
 <tbody> 
 <tr> 
 <td> C语言是在实践的过程中逐步完善起来的 没有深思熟虑的设计过程 使用时存在很多“灰色地带”&nbsp;&nbsp; i++i++i++ 残留量过多低级语言的特征 直接利用指针进行内存操作 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> C语言的目标是高效 最终程序执行效率的高效 </td> 
 </tr> 
 <tr> 
 <td> 当面向过程方法论暴露越来越多的缺陷的时候，业界开始考虑在工程项目中引入面向对象的设计方法，而第一个需要解决的问题就是：高效的面向对象语言，并且能够兼容已经存在的代码。 C语言 + 面向对象方法论&nbsp; -----&gt;&nbsp;&nbsp; Objective C /C++ </td> 
 </tr> 
 <tr> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> C语言和C++并不是对立的竞争关系 C++是C语言的加强，是一种更好的C语言 C++是以C语言为基础的，并且完全兼容C语言的特性 </td> 
 </tr> 
 <tr> 
 <td> 学习C++并不会影响原有的C语言知识，相反会根据加深对C的认知； 学习C++可以接触到更多的软件设计方法，并带来更多的机会。 1）&nbsp; C++是一种更强大的C，通过学习C++能够掌握更多的软件设计方法 2）&nbsp; C++是Java/C#/D等现代开发语言的基础，学习C++后能够快速掌握这些语言 3）C++是各大知名软件企业挑选人才的标准之一 </td> 
 </tr> 
 <tr> 
 <td> 送给在路上的程序员 对于一个开发者而言，能够胜任系统中任意一个模块的开发是其核心价值的体现 对于一个开发团队而言，在短期内开发出用户满意的软件系统是其核心竞争力的体现 对于一个架构师而言，掌握各种语言的优势并合理运用到系统中，由此简化系统的开发，是其架构生涯的第一步 每一个程序员都不能固步自封，要多接触新的行业、新的技术领域。暂新的突破自 &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

![Image 1][]

# 3C++对C的加强 #

加强的内容主要有：namspace命名空间；register；语法增强；bool类型；三目运算符；const；引用；inline等。

首先我们看一下所谓面向过程和面向对象编程的思想，看下面的代码：

//包含头文件
 #include "iostream"
 
 using namespace std;
 
 /********面向过程的方法*********/
 void main1()
 {
 	double r;
 	double s;
 	cout << "请输入圆的半径:";
 	cin >> r;
 	s = 3.14*r*r;
 	cout << "面积是" << s << endl;
 
 	system("pause");
 }
 
 
 
 /********面向对象的方法*********/
 class circle
 {
     //成员变量
 private:
     double m_r;
 
     //成员函数                
 public:			
 	void setR(double r)	
 	{
 		m_r = r;
 	}
 	double getR()
 	{
 		return m_r;
 	}
 	double getS()
 	{
 		return 3.14*m_r*m_r;
 	}
 };
 
 void main()
 {
 	circle c1;
 	c1.setR(10);
 	cout << "半径是" << c1.getR() << endl;
 	cout << "面积是" << c1.getS() << endl;
 	system("pause");
 }

面向过程是逐过程执行，而面向对象是先把所有人、事、事物统统抽象成类，类中定义了其属性（成员变量）和方法（成员函数）。

**1. namespace命名空间**

在C++中，名称（name）可以是符号常量、变量、宏、函数、结构、枚举、类和对象等等。为了避免在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。

std是c++标准命名空间，c++标准程序库中的所有标识符都被定义在std中，比如标准库中的类iostream、vector等都定义在该命名空间中，使用时要加上using声明(using namespace std)  或using指示(如std::string、std::vector<int>).

C和C++的区别是

C中的命名空间

在C语言中只有一个全局作用域

C语言中所有的全局标识符共享同一个作用域

标识符之间可能发生冲突

C++中提出了命名空间的概念

命名空间将全局作用域分成不同的部分

不同命名空间中的标识符可以同名而不会发生冲突

命名空间可以相互嵌套

全局作用域也叫默认命名空间

C++命名空间的定义：

namespacename \{  … \}

C++命名空间的使用：

使用整个命名空间：usingnamespace name;

使用命名空间中的变量：using name::variable;

使用默认命名空间中的变量：::variable

默认情况下可以直接使用默认命名空间中的所有标识符

namespace NameSpaceA
    {
    	int a = 0;
    }
    
    namespace NameSpaceB
    {
    	int a = 1;
    
    	namespace NameSpaceC
    	{
    		struct Teacher
    		{
    			char name[10];
    			int age;
    		};
    	}
    }
    
    int main()
    {   
        using namespace NameSpaceA;
        printf("a = %d\n", a);
        printf("a = %d\n", NameSpaceB::a);
        
        using NameSpaceB::NameSpaceC::Teacher;
        Teacher t1 = { "aaa", 3 };
        printf("t1.name = %s\n", t1.name);
        printf("t1.age = %d\n", t1.age);
    
        system("pause");
        return 0;
    }

#  结论 #

1）当使用<iostream>的时候，该[头文件][Link 1]没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。若不引入using namespace std ,需要这样做。std::cout。

2）  c++标准为了和C区别开，也为了正确使用命名空间，规定[头文件][Link 1]不使用后缀.h。

3）  C++命名空间的定义：   namespace name \{  …  \}

4）  using namespace NameSpaceA;

5）namespce定义可嵌套。

**2.register关键字功能增强**

\------VC6.0不添加system("pause")，也会等待输入结束，但是VS版本如果没有，执行起来会一闪而过，所以VS版本必须添加system("pause")。

register这个关键字请求编译器尽可能的将变量存在CPU内部寄存器中，而不是通过内存寻址访问，以提高效率。**注意是尽可能，不是绝对**。

使用register修饰符有几点限制：

首先，register**变量必须是能被CPU所接受的类型**。这通常意味着register变量**必须是一个单个的值**，并且**长度应该小于或者等于整型的长度**。不过，有些机器的寄存器也能存放浮点数。

其次，因为register变量可能不存放在内存中，所以 不能用 “&” 来获取 register 变量的地址。 但是C++中是会被优化的，可以获取地址。

<table> 
 <tbody> 
 <tr> 
 <td> //register关键字 请求编译器让变量a直接放在寄存器里面，速度快 //在c语言中 register修饰的变量 不能取地址，但是在c++里面做了内容 //1 register关键字的变化 register关键字请求“编译器”将局部变量存储于寄存器中 C语言中无法取得register变量地址 在C++中依然支持register关键字 C++编译器有自己的优化方式，不使用register也可能做优化 C++中可以取得register变量的地址 //2 C++编译器发现程序中需要取register变量的地址时，register对变量的声明变得无效。 //3 早期C语言编译器不会对代码进行优化，因此register变量是一个很好的补充。 </td> 
 </tr> 
 </tbody> 
</table>

**3.全局变量的区别**

.c中，重复定义，比如int t; int t = 0; 这样是不会报错的。但是C++中，是会报错 重命名。

**4.struct类型加强**

struct类型的加强：

C语言的struct定义了一组变量的集合，C编译器并不认为这是一种新的类型

C++中的struct是一个新类型的定义声明

struct Student
    {
        char name[100];
        int age;
    };
    
    int main(int argc, char *argv[])
    {
        Student s1 = {"wang", 1};
        Student s2 = {"wang2", 2};    
        return 0;
    }

Student在C++中是一个新的类型（类），类是把属性和方法进行了打包抽象。

**5.C++中所有的变量和函数都必须有类型**

C++中对类型的检查更加严格，C++中所有的变量和函数都必须有类型，C语言中的默认类型在C++中是不合法的。

C中可以这样的：

//更换成.cpp试试
    
    f(i)
    {
    	printf("i = %d\n", i);
    }
    
    g()
    {
    	return 5;
    }
    
    int main(int argc, char *argv[])
    {
    	f(10);
    	printf("g() = %d\n", g(1, 2, 3, 4, 5));
    	getchar();	
    	return 0;
    }

总结：

在C语言中

int f(    );      表示返回值为int，接受任意参数的函数

int f(void);   表示返回值为int的无参函数

在C++中

int f(  );和int f(void)具有相同的意义，都表示返回值为int的无参函数

C++更加强调类型，任意的程序元素都必须显示指明类型

**6.bool类型**  
bool类型只有两个值 0  1，占一个字节。

**7.三目运算**

三目运算符是一个表达式，表达式不可能做左值。

int main()
 {
 	int a = 10;
 	int b = 20;
 	int c;
 	//三目运算符不可做左值
 	(a < b ? a : b) = 30;
 	//正确用法
 	c = (a < b ? a : b);
 	printf("c:%d", c);
 	system("pause");
 }

在C++中，三目运算符返回的是一个变量的值。  
**8.const**

const int \*a; a指向的内存空间不能操作修改

int const \*a; a的地址不能修改

但是我们需要非常注意的是，C和C++是不一样的，看下面你的代码：

int main()
    {
    	const int a = 10;
    	int *p = NULL;
    	p = (int *)&a;
    	printf("a:%d\n", a);
    	*p = 11;
    	printf("a:%d\n", a);
    	system("pause");
    }

C中，执行的代码结果是a的值改变了，但是C++中，a的值是无法修改的，而且\*p的值是11。这说明了什么问题呢？？？？？？？？？

在C语言中，const是一个冒牌货。const int a =10;a只是一个只读的量，可以通过指针绕过去修改。

在C++中，上面代码

p = (int *)&a;

当对a进行取地址的时候，有一个内存空间(&a)，但是a的地址真的是a的地址吗？？？

在C++中，通过const修饰的东西， 会变成什么样子？？const int a=10;此时，C++编译器是把a放在C++里面的符号表

key    =   value;

a              10

但是这个符号表 放在内存哪个区里面呢？？其实我也不知道，老师也不知道。你也就无法修改a的值。当你取地址时，编译器会立即新开辟一个内存空间赋值为10，当

p = (int *)&a;

p得到的地址其实是C++编译器临时分配的内存空间地址。而且只分配一次，当再次取地址时，仍然是新分配的那个内存地址。你如何根据地址修改a的值，根本与符号表里的a的值没有任何关系，所以你就无法对const a的值操作修改。

**结论：**

当碰见常量声明时，在符号表中放入常量，但是如果在编译过程中，编译器发现对const使用了extern或&操作符，则对相应的常量分配内存空间。

C语言中的const变量是只读变量，有自己的存储空间。

C++中的const变量，可能分配内存空间，也可能不分配内存空间，分配内存空间的情况有：

当const常量为全局变量，并且需要在其他文件中使用

当使用&操作符取const变量的地址

另外，const和define的区别：

C++中的const常量类似于宏定义

const int c =5;  <--->  define c 5;

C++中的const常量与宏定义不同

const常量是有编译器处理的，提供类型检查和作用域检查

宏定义由预处理处理，单纯的文本替换。

最重要的区别是作用域不一样，在一个函数体内定义宏定义，在另一个函数体内是可以使用的。

如果不想在另一个函数体内使用，可以这样定义限定宏定义的使用范围。

#define a 10
    ********
    #undef

**9.引用（普通引用）**

回忆三句话：

变量名实质上是一段连续存储空间的别名，是一个标号

程序中通过变量来申请来命名内存空间

通过变量的名字可以使用存储空间

引用的使用：

void int main(int argc, char const *argv[])
    {
        int a = 10;
        //引用的语法：type & 引用名字 = 被引用的变量
        int &b = a;
    
        b = 11;
        printf("a:%d\n", a);
        printf("b:%d\n", b);
        
        return 0;
    }

在使用引用的时候，引用相当于变量的别名。上面修改了b的值，也会修改a的值。  
看下面的代码对比：

void swap1(int &a, int &b)
    {
    	int c;
    	c = a;
    	a = b;
    	b = c;
    }
    
    void swap2(int *a, int *b)
    {
    	int c;
    	c  = *a;
    	*a = *b;
    	*b = c;
    }
    void main()
    {
    	int a1 = 10;
    	int b1 = 20;
    
    	swap1(a1, b1);
    	printf("a1:%d, b1: %d\n",a1, b1);
    
    	swap2(a1, b1);
    	printf("a1:%d, b1: %d\n",a1, b1);
    	
    	system("pause");
    }

我们可以发现引用和指针的联系！！！！ 也就是说，引用在一定时候可以替换指针使用。  
继续show codes

struct Teacher
    {
    	int &a;
    	int &b;
    };
    
    void int main(int argc, char const *argv[])
    {
    	printf("%d\n", sizeof(Teacher));
    	return 0;
    }

引用会占用内存。

引用的本质：

1) 引用在C++的内部实现是一个常指针

Type& name <---->Type\* const name

2) C++编译器在编译过程中，使用常指针作为引用的内部实现，因此引用占用的空间大小和指针相同。

3) 从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间，这是C++为了实用性而做出的细节隐藏。

4) 请仔细对比间接赋值成立的三个条件

1.定义两个变量（一个实参一个形参）

2.建立关联， 实参取地址传给形参

3. \*p形参去间接的修改实参的值

5) C++引用注意

当函数返回值为引用时，若返回栈变量\\不能成为其他引用的初始值\\不能作为左值使用