C++笔记2 数组和指针

using namspace std;  打开之后有冲突 和别的定义冲突，
比如我们定义一个struct Cout类型 Cout cout   他就和std的命令空间中cout冲突，

5 种存储类型
自动类型auto
register
extern
static
mutable

auto 在旧的类型C++98是 存储类别 是分布在栈区的自动对象
在新的标准中C++11是自动类型推断  他推断n是整形
auto n=9; 自动类型推断  他推断n是整形
auto ar[] {1,2,3}  是自动类型推断

声明的组成：
存储类别+数据类型+名字+可选的初始化式   

标识符由
1，大小字母和数字下划线组成
2，__开头的变量是系统的变量
3，只能以字母和下划线开头
4， C／C++关键字

-std=C++11;

C++11
auto n=9; 自动类型推断  他推断n是整形
auto ar[] {1,2,3}  是自动类型推断
他的用途主要是 做复杂类型的数据推断
要让这个类型推断生效  编译的时要加-std=c++11

1,可以抄一边
2，用 -s

decltype(m1) m   //产生一个与m1相同的类型

int i
decltype(i) n;//创建一个 与i相同的类型；  是用来产生类型的

static const decltype(i) n =1000;

sizeof 是操作符     编译器首先确定他的类型，事先确定的
+是运行期确定的，是操作符

auto decltype 是 操作符   是编译期确定， 编译
templeate< T>
auto foo (T1 x,T1 y) -> decltype(x+y)   模板编译期确定他的类型  因为编译的时候就已经确定他的类型 ，编译的时候传进去参数

C++内存模型   编译的代码是在text中
text
数据初始化区，
数据未初始化区；bss
堆区
栈区


数组的位数和数组的长度 是在编译期确定的

int n
sizeof n;
sizeof(int); 是个操作符

return (n);

运算符 和操作符 本质是一样的   operator;

数组
1,容纳相同类型的对象，而且是在连续的内存分布，

1，通过下标操作符来访问
2， 指针

int* p=ar;
p[0]=1000; []是操作指针   ［］可以用于指针， 用于数组

下表向后移

double da[2][3];// 一个有两个元素

int  数组的

//
int nd[3];

nd 是个指针，  数组名本身就是个指针


指针，
问题：
1，使用未初始化指针  （包括空指针）   
int＊p   这是因为p指针没指定指向哪个对象
*p=100;     ／／是未定义行为；
正常
int k -0;
int* p=&k;
*p=100;

new是分三步；
第一步： 首先在堆中分配一块内存
第二步： 调用构造函数来进行初始化
第三步： 返回一个指向这块内存的指
在堆区分配一块内存
2，调用内置构造函数
int * p =new int;
*p=100;

2，悬挂指针  --野指针
int* p1=new int(8)
int* p2=p1;
int* p3=p2;
delete p3;  ，   给系统说 标识一下 我不用啦
*p2=1000;  对象已经被释放，，
 未定义行为  
1，我对象释放的那  还在
2，这内存被重新 分配，  在我们这一个进程， 这个进程修改别的可写的对象
3，const 对象， 修够
4，段错误：修改别的进程的区域； 直接崩溃， 内存保护， 他不能修改别的进程，

3，内存泄漏
   没有被释放，也不能被使用，
   int f()
{
      {
           int *p=new int(100)     一旦内存泄漏，电脑重启， 内存回归
        }
}
4，多次释放
  指针多次释放
bss

内存大小是由我们的系统硬件内存条确定的
堆占四分之三   由我们自己管理
栈占四分之一  系统管，

任何地址都有对象；

abort

4G是地址值
地址是怎么产生的，
通过取址操作符 (&) 获取其它对象的地址
指向一个数组

不同类型的指针本身是一样大的
但是指针本身在别处还保存有类型信息， 类型信息占多大的内存， 这些类型信息是放到别处的
解引用是 dereference;

nullptr_t类型 nullptr  false true  'C' char   是字面常量；

指针和数组的关系；

int ar[5];
ar+=2;//他是错误的
ar首地址是是const  是不可改变的，  如果他可以改变的， 数组就偏移的

int  ar[2][3];
int **p =ar;

int (*q)[3]=ar;

一个指针指向一个素

int* p[5];//指向一个
int (*q)[5];他是一个指针， 这个指针是指向一个存放5个元素的数组   就是指针数组，指向数组的指针

 cdecl 表达式

char* p1="abc";
p1[0］=X;／／这是错误的／／  因为abc是常量，p1指针是指向这个常量 ，你修改这个常量是不行的
char ca[]="abcd";

正确用法：  const char*p2="abcd";  

const *  左量又针
引用和指针的差别：
1，引用是对象的别名，指针是对象的地址
2，定义引用时要初始化，而指针可以不先初始化
3，引用的对象不能被修改，而指针可以被修改

引用的作用是：  是为啦降低对指针的依赖
void

引用不接受右值
int & r =1;   引用不能引用一个临时对象；
只接受左值；

只接受一种左值
const int& r=1;

short s =8;
int&r =s;    temp=(int)s;  short是右值

越界访问  

void ＊ 主要用在