C++技术点积累(1)

C++技术点积累：

一、入门基础篇

1、面向过程加工的是：一个一个的函数；——主要解决科学计算问题，用户需求简单而固定       

l 设计思路

– 自顶向下、逐步求精。采用模块分解与功能抽象，自顶向下、分而治之。

l 程序结构：

– 按功能划分为若干个基本模块，形成一个树状结构。

– 各模块间的关系尽可能简单，功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成。

– 其模块化实现的具体方法是使用子程序。

l 优点：

有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。

l 缺点：可重用性差、数据安全性差、难以开发大型软件和图形界面的应用软件

– 把数据和处理数据的过程分离为相互独立的实体。

– 当数据结构改变时，所有相关的处理过程都要进行相应的修改。

– 每一种相对于老问题的新方法都要带来额外的开销。

– 图形用户界面的应用程序，很难用过程来描述和实现，开发和维护也都很困难。

面相对象加工的是：一个一个的类；由现实世界建立软件模型，将现实世界中的事物直接映射到程序中，可直接满足用户需求。直接分析用户需求中涉及的各个实体，在代码中描述现实世界中的实体，在代码中关联各个实体协同工作解决问题。

l 将数据及对数据的操作方法封装在一起，作为一个相互依存、不可分离的整体——对象。

l 对同类型对象抽象出其共性，形成类。

l 类通过一个简单的外部接口，与外界发生关系。

l 对象与对象之间通过消息进行通信。

面向对象的基本概念 ：

a.对象

l 一般意义上的对象：

– 是现实世界中一个实际存在的事物。

– 可以是有形的（比如一辆汽车），也可以是无形的（比如一项计划）。

– 是构成世界的一个独立单位，具有

l 静态特征：可以用某种数据来描述

l 动态特征：对象所表现的行为或具有的功能

l 面向对象方法中的对象：

– 是系统中用来描述客观事物的一个实体，它是用来构成系统的一个基本单位。对象由一组属性和一组行为构成。

– 属性：用来描述对象静态特征的数据项。

– 行为：用来描述对象动态特征的操作序列。

b.类 

l 分类——人类通常的思维方法

l 分类所依据的原则——抽象

– 忽略事物的非本质特征，只注意那些与当前目标有关的本质特征，从而找出事物的共性，把具有共同性质的事物划分为一类，得出一个抽象的概念。

– 例如，石头、树木、汽车、房屋等都是人们在长期的生产和生活实践中抽象出的概念。

l 面向对象方法中的"类"

– 具有相同属性和服务的一组对象的集合

– 为属于该类的全部对象提供了抽象的描述，包括属性和行为两个主要部分。

– 类与对象的关系：
犹如模具与铸件之间的关系，一个属于某类的对象称为该类的一个实例。

c.封装 

也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

l 把对象的属性和服务结合成一个独立的系统单元。

l 尽可能隐蔽对象的内部细节。对外形成一个边界（或者说一道屏障），只保留有限的对外接口使之与外部发生联系。

l 继承对于软件复用有着重要意义，是面向对象技术能够提高软件开发效率的重要原因之一。

l 定义：特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。

l 例如：将轮船作为一个一般类，客轮便是一个特殊类。

d.多态 

多态是指在一般类中定义的属性或行为，被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在一般类及其各个特殊类中具有不同的语义。

2、为什么需要成员函数？———成员函数的作用

class circle
{
public:
	double r;
	double pi = 3.1415926;
	double area = pi*r*r;
};

int main()
{
	circle c1;
	cout << "please input your r" << endl;
	cin >> c1.r;      //虽然赋值了，但是并没有执行pi*r*r

	cout << c1.area << endl;	//乱码        //只是去取值，并不会去计算
	return 0;
}

从内存四区的角度，解释为什么会出现乱码，理解为什么需要成员函数！r在初始化的时候是一个乱码（随机值），也就造成“area=pi*乱码*乱码”成了一个乱码。虽然后来对r赋值了，但是编译器并不会执行pi*r*r，没有机会执行pi*r*r——没有成员函数、没有调用成员函数，编译器只会从area标识的内存空间机械的取值，也就取出了初始的乱码。

3、命名空间的作用：——分割标识符的作用域，防冲突

C中的命名空间
在C语言中只有一个全局作用域
C语言中所有的全局标识符共享同一个作用域
标识符之间可能发生冲突  
C++中提出了命名空间的概念——为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时这些标识符的命名发生冲突，标准C++引入了关键字namespace（命名空间/名字空间），可以更好地控制标识符的作用域。
命名空间将全局作用域分成不同的部分
不同命名空间中的标识符可以同名而不会发生冲突
命名空间可以相互嵌套
全局作用域也叫默认命名空间

namespace NameSpaceA
{
	int a = 0;
}

namespace NameSpaceB
{
	int a = 1;

	namespace NameSpaceC
	{
		struct Teacher
		{
			char name[10];
			int age;
		};
	}
}

int main()
{
	using namespace NameSpaceA;
	using NameSpaceB::NameSpaceC::Teacher;

	printf("a = %d\n", a);//只是导入了NameSpaceA<span style="font-family: Arial, Helvetica, sans-serif;">的a</span>
	printf("a = %d\n", NameSpaceB::a);//导入的是NameSpaceB中的NameSpaceC中的Teacher，所以在此需要专门导入NameSpaceB中的a

	Teacher t1 = {"aaa", 3};

	printf("t1.name = %s\n", t1.name);
	printf("t1.age = %d\n", t1.age);
	return 0;
}

4、C++中的const：c语言中的const是一个冒牌货，C++语言中 const是一个真正的常量。对于下面的程序在C编译器和C++编译器中分别执行：

void main()
{
	const int a = 10;
	int *p = NULL;
	p = (int *)&a;

	*p = 20;  //间接赋值 

	printf("a:%d \n", a);//打印的是“符号表”中的a
	printf("*p:%d \n", *p);//打印出20，证明另外分配了内存空间
}

上述程序在C编译器中打印的a为20，在C++编译器中打印的a仍为10。

原因分析：
C++编译器对const常量的增强处理：
当碰见常量声明时，在“符号表”（C++编译器专门设置的）中放入常量
编译过程中若发现使用常量则直接以符号表中的值替换（上述的打印a证明了这一点）
编译过程中若发现对const使用了extern或者&操作符，则给对应的常量另外再专门分配另外的存储空间（上述的打印*p证明了这一点）
C++编译器虽然可能为const常量分配空间，但不会使用其存储空间中的值。

结论：
C语言中的const变量
      C语言中const变量是只读变量，有自己的存储空间（所以在C编译器中，可以通过指针去绕过const这道墙）
C++中的const常量
      可能分配存储空间，也可能不分配存储空间  
      当const常量为全局，并且需要在其它文件中使用，会分配存储空间
      当使用&操作符，取const常量的地址时，会分配存储空间
      当const int &a = 10; const修饰引用时，也会分配存储空间

5、引用——引用在C++中的内部实现是一个常指针

普通引用在声明时必须用其它的变量进行初始化，引用作为函数参数声明时不进行初始化。

C++引用使用时的难点：
（1）当函数返回值为引用时，若返回栈变量，不能成为其它引用的初始值，不能作为左值使用（局部变量的内存空间已经被析构）；
（2）若返回静态变量或全局变量，可以成为其他引用的初始值，即可作为右值使用，也可作为左值使用；

a.函数返回值是引用：

int getAA1()
{
	int a;
	a = 10;
	return a;    //虽然getAA1()在运行结束后会释放内存空间，但是值已经甩出来了
}

//返回a的本身——返回a的一个副本，10 
int& getAA2()
{
	int a;       //如果返回栈上的 引用（局部变量）, 有可能会有问题   
	a = 10;
	return a;
}

void main()
{
	int a1 = 0;
	int a2 = 0;
	a1 = getAA1();//10，虽然getAA1()在运行结束后会释放内存空间，但是值已经甩出来了

	//getAA2()返回a的本身，关键是看用什么去接
	a2 = getAA2(); //10，返回a的本身——返回a的一个副本，10 
	int &a3 = getAA2();  //乱码——若返回栈变量	不能成为其它引用的初始值

	printf("a1:%d \n", a1);
	printf("a2:%d \n", a2);
	printf("a3:%d \n", a3);  // *a3   //Debug下为乱码   //release下为10   ————潜在的bug
}

b.变量是static 或者是 全局变量：

int j1()
{
	static int a = 10;
	a ++ ;
	return a;
}

int& j2()
{
	static int a = 10;
	a ++ ;
	return a;
}

//若返回静态变量或全局变量
//	可以成为其他引用的初始值
//	即可作为右值使用，也可作为左值使用
void main1112()
{
	int a1 = 10;
	int a2 = 20;

	a1 = j1();
	a2 = j2();
	int &a3 = j2();

	printf("a1:%d \n", a1);    //11
	printf("a2:%d \n", a2);    //11
	printf("a3:%d \n", a3);    //12，静态变量，又调用了一次j2()
	system("pause");
}

c.函数当左值：

//返回变量的值
int g1()
{
	static int a = 10;
	a++;
	return a;  
}

//返回变量本身，也就是返回变量所标识的内存空间  
int& g2()
{
	static int a = 10;
	a++;
	printf("a:%d \n", a);
	return a;
}

void main()
{
	// g1() = 100;  //此句报错，返回的是变量的值——11 = 100;

	g2() = 100; //此句正确，函数返回值是一个引用,并且当左值
	            //打印11，并且把局部的静态变量a改成了100
	g2();       //打印101

	int c1 = g1(); //函数返回值是一个引用,并且当右值 
	int c2 = g2(); //函数返回值是一个引用,并且当右值
	printf("c1:%d    c2:%d\n", c1, c2);//11 , 102
}

d.指针的引用：

struct Teacher
{
	char name[64];
	int age ;
};

//在被调用函数 获取资源 
int getTeacher(Teacher **p)
{
	Teacher *tmp = NULL;
	if (p == NULL)
	{
		return -1;
	}
	tmp = (Teacher *)malloc(sizeof(Teacher));
	if (tmp == NULL)
	{
		return -2;
	}
	tmp->age = 33;
	// p是实参的地址  *实参的地址 去间接的修改实参的值
	*p = tmp; 
}

//指针的引用 做函数参数
//简单分析时，可以把引用仅仅当做一个“别名”而已
int getTeacher2(Teacher* &myp)
{
	//给myp赋值 相当于给main函数中的pT1赋值
	myp = (Teacher *)malloc(sizeof(Teacher));
	if (myp == NULL)
	{
		return -1;
	}
	myp->age = 36;
}

void FreeTeacher(Teacher *pT1)
{
	if (pT1 == NULL)
	{
		return ;
	}
	free(pT1);
}

void main1201()
{
	Teacher *pT1 = NULL;

	//1 c语言中的二级指针
	getTeacher(&pT1);
	cout<<"age:"<<pT1->age<<endl;
	FreeTeacher(pT1);


	//2 c++中的引用 （指针的引用）
	getTeacher2(pT1);

	cout<<"age:"<<pT1->age<<endl;
	FreeTeacher(pT1);
}

e.常量引用
const引用——让变量拥有只读属性。