第二章 C++基础（Ⅰ）

（1）C++对C语言数据类型的扩展

不必在结构名、联合名、枚举名前加上前缀
此外在结构和联合中还可定义函数

（2）左值、右值、局部变量声明的改进

左值指内存区域，用变量名进行操作


内存区域中的内容则称为它的右值

（3）指针

指针变量 p 所需要的内存大小都相同（取决于系统字长），与数据类型无关


p 保存的地址，实质是某个内存区域的首地址

1 空指针

NULL
0
nullptr（C++11引入）

2 void*

使用之前必须显式的将其转化为某种数据类型的指针

3 begin() end()

头文件#include<iterator>
int a[]={1,2,3,4,5,6,7,8,9,10};
begin(a) 　　　　　　　返回的是指向a[0]的指针
end(a)　　　　　　　　返回的是指向最后元素后一位置的指针

4 new和delete/malloc和free

• malloc和free

  在头文件stdlib.h中

  int *p=(int *)malloc(100);            //指向整型的指针p指向一个大小为100字节的内存的地址
  int *p=(int *)malloc(25*sizeof(int)); //指向整型的指针p指向一个25个int整型空间的地址
  

  因为malloc()函数的返回值类型为void *，所以需要在函数前面进行相应的强制类型转换。当int占4个字节内存时，上述的两个语句代码获得的内存空间大小是相同的。分配内存后必须验证内存是否分配成功，完成后用free()释放内存，完整语句如下。

  int *p=(int *)malloc(int);
  if(p==NULL)
  	printf("Out of memory!\n");
  free (p);
  

• new和delete

  如下几行代码：

  int *pi=new int;//第一行这个new表达式在自由存储区中分配创建了一个整形对象，并返回一个指向该对象的地址来初始化指针pi
  int *pi=new int();//第二行同一行，只是对指针pi指向的地址的值进行了初始化为0
  int *pi=new int(1024);//第三行初始化为1024
  

  当动态创建的对象用完后必须释放内存，避免造成内存泄漏，可以用delete来完成，new和delete是成对使用的，如下命令释放pi指向的int型对象所占用的内存空间：

  delete pi;
  

  此时·pi尽管没有定义，但仍然存放了它所指向对象的地址，然而pi所指向的内存已经被释放，因此pi不再有效。建议一旦删除指针所指向的对象，立即将指针置为0，这样就清楚的表明指针不再指向任何对象。

  当创建一个动态数组对象和进行内存释放时，执行以下语句：

  int *pi=new int[];               //指针pi所指向的数组未初始化
  int *pi=new int[n];             //指针pi指向长度为n的数组，未初始化
  int *pi=new int[]();            //指针pi所指向的地址初始化为0
  delete [] pi;                   //回收pi所指向的数组
  

• new和malloc的区别

a.属性

new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头>文件支持c。


b.参数

使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类>型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。


c.返回类型

new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。


d. 分配失败

new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时返回NULL。


e.自定义类型

new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。


malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。


f.重载

C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。

• 智能指针

1. 智能指针的作用

程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。

2. 智能指针的使用

智能指针在C++11版本之后提供，包含在头文件<memory>中，shared_ptr、unique_ptr、weak_ptr

定义形式：

	x_ptr<type> p;
	x_ptr<type> p2(p);
	x_ptr<type> p3(new type(x));

两个成员函数：

p.get() 　　　//能够返回ｐ中保存的指针
p.swap(p1)　//交换指针的内容

智能指针与普通指针之间不能够随意赋值，不能把智能指针指向普通内存变量，或者把非智能指针赋值给智能指针。直接把智能指针赋值给普通指针是错误的，要通过get()成员函数获取智能指针中的指针后，再赋值给普通指针

同类型的auto_ptr 、shared_ptr智能指针之间可以相互赋值，unique_ptr指针之间则不允许相互赋值

auto_ptr(已弃用):

auto_ptr的出现，主要是为了解决“有异常抛出时发生内存泄漏”的问题。如下的简单代码是这类问题的一个简单示例。

int* p = new int(100);
try
{
    doSomething();
    cout << *p << endl;
    delete p;
}
catch(exception& e)
{
}

当doSomething();部分抛出异常，将导致指针p所指向的空间得不到释放而导致内存泄露。auto_ptr的引入解决了这类问题。

#include<iostream>
using namespace std;
int main()
{
	auto_ptr<string> p1(new string ("only onepoint to me"));
	auto_ptr<string> p2;
	p2=p1;							//L1p1不再指向任何对象，其所指对象由p2指向
	cout<<*p1;						//L2发生运行错误，因为p1没有指向任何对象
	cout<<*p2<<endl;				//L3输出 ：only onepoint to me
	//p1=new string("dd")			//L4错误，不能用这种方式给智能指针赋值
	auto_ptr<string> p3(p2); 		//L5p2不再指向任何对象，其所指对象由p3指向
	cout<<*p3<<endl;				//L6输出：only onepoint to me 
	cout<<*p2<<endl;				//L7发生运行错误，因为p2没有指向任何对象
}

智能指针被定义后，可以像L2、L3那样进行解引用，也只能像定义p1、p3那样在定义智能指针的的时候直接分配空间或者用已定义指针进行初始化，或者像L1语句进行同类指针之间的赋值，而不能像L4一样直接用new为它分配空间


为auto_ptr创建的动态对象，只能有一个auto_ptr类型的智能指针指向它。


当程序结束后，auto_ptr指针会自动被销毁，不用delete

shared_ptr和unique_ptr:

• unique

unique_ptr持有对对象的独有权，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义，禁止了指针之间的赋值，也不可以用一个指针来初始化另一个指针，只有移动语义来实现）。


unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。


离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。

• shared_ptr

shared_ptr 允许多个该智能指针共享第“拥有”同一堆分配对象的内存，这通过引用计数（reference counting）实现，会记录有多少个shared_ptr共同指向一个对象，一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。


另：weak_ptr
weak_ptr 是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作，它可以从一个 shared_ptr 或另一个 weak_ptr 对象构造，它的构造和析构不会引起引用计数的增加或减少。

（4）引用

引用：就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。

左值引用:

左值引用的声明方法：类型标识符 &引用名=目标变量名；

例：

char ch;
char &rp=ch;

1)引用仅是变量的别名，而不是实实在在地定义了一个变量，因此引用本身并不占用内存，而是和目标变量共同指向目标变量的内存地址.


2)表达式中的取地址符&不再是取变量的地址，而是用来表示该变量是引用类型的变量。


3)定义一个引用时，必须对其初始化。

4)建立引用时应当类型匹配


5)可以有引用数组或者数组元素的引用，但是不能有引用数组
如下:

int main()
{
	int i=0,a[10]={1,2,3,4,5,6,7,8,9,10},*b[10];
	int (&ra)[10]=a;					//正确，这是对数组a[10]的引用 
	int &&aa=a[0];  					//正确，这是对数组元素的引用
	int *(&rpa)[10]=b;					//正确，是对具有10个整型指针的数组的引用
	int &ia[10]=a;						//错误，ia变成了引用数组，每个元素都为引用 
}

6)指针与引用
可以建立指针的引用,但不能创建指向引用的指针
定义方式:

int i;
int &*ip=i;							//错误,ip是指向引用的指针
int *pi=&i;
int *&pr=pi;						//正确,pr是指针的引用

右值引用:

等号右边应该为一个计算表达式，不能只有一个变量

部分内容转自其他博客…具体链接不记得了…