无论什么类型，都占4个字节（在win32位系统中）

//定义指针
int a=10;
int *p;
p=&a;//为指针赋值（地址）

//使用指针
*p;//解指针，指向内存中的数

• 定义：指针变量指向内存中编号为0的空间
• 用途：初始化指针变量int *p = NULL
• 注意：空指针指向的内存是不能访问的（0~255为系统占用内存，不允许用户访问）

• 指针变量指向非法的内存空间
• int *p = (int *)0x1100

• const修饰指针——常量指针
  const int *p = &a
  指针的指向可以改，指针指向的值不可以改
• const修饰常量——指针常量
  int * const p = &a
  指针的指向不可以改，指针指向的值可以改
• const既修饰指针，又修饰常量
  const int * const p= &a
  指针的指向和指向的值都不能改

• 与数组
  int *p = arr//指向数组首地址
• 函数

  int a=10,b=20;
  swap(&a,&b);
  
  void swap(int *p1.int *p2){int temp = *p1;
      *p1=*p2;
      *p2=temp;
  }

  p++;//函数的运算

在定义时，不可以省略struct关键字；在使用时，可以省略struct关键字。

//定义结构体（以下皆以此为例）
struct Student{string name;
 int age;
}; 

//创建结构体变量，三种使用方法
struct Student s; s.name="000"; s.age=20;
struct Student s={"000",20}
在定义结构体后创建变量，随后赋初值

• 与数组

  //创建数组变量
  struct Student s[2]{{"000",20};
      {"001",21};
  };
  
  //使用
  s[i].name

• 与指针

  //创建指针变量
  Student s={"000",21};
  Student *p = &s;
  
  //使用
  p->name

不修改主函数中的数据，使用值传递。修改主函数中的数据，使用地址传递

struct Student s;
void printf1(struct Student p){p.name…………}//值传递
printf1(s);

void printf2(struct Student *p){p->name…………}//地址传递
printf2(&s);

使用指针进行传递，可以减少内存空间，而且不会复制新的副本。
而使用const修饰结构体Student const *p能够防止误操作

在头文件.h中,只有属性与行为函数的声明

//该文件名为test.h
#pragma once//防止头文件重复包含
#includeusing namespace std;

class P{public:
    void setX(int x);
    int getX();

private:
    int p_x;
}

在源文件.cpp中，只有行为函数所有的实现

#include "test.h"//包含头文件名

//此时为全局函数，需要加上作用域成为成员函数
void P::setX(int x){p_x=x;
}
int P::getX(){return p_x;
}

四个区域，代码区、全局区、栈区、堆区
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程
在程序编译后，会生成exe可执行程序
四个分区可分为程序执行前（代码区、全局区）与程序执行后（栈区、堆区）

存放函数体的二进制代码（CPU执行的机器指令），由操作系统进行管理

• 共享的，对于频繁执行的程序，只需在内存中有一份代码即可
• 只读的，防止程序意外修改了其中的指令

存放全局变量、静态变量、常量（字符串常量，const修饰全局变量）
该区域的数据在程序结束后由操作系统释放

由编译器自动分配释放，存放函数的参数值、局部变量等
不要返回局部变量的地址

由程序员分配（new）和释放（delete），若程序员不释放，程序结束时由操作系统回收

在堆区创建数据，返回该数据对应类型的指针

• 基本语法

  int * a = new int(10);//创建
  delete a;//释放

• 开辟数组

  int * arr = new int [10];//创建
  delete[] arr;//释放

• 作用：给变量起别名（用不同的变量名操作同一块内存空间）

• 语法：数据类型 &别名 = 原名

• 注意：引用必须要初始化；初始化后不能再更改

• 本质：是一个指针常量（指向不可改，值可改）

  int a=10;
  int &ref = a;//自动转换为`int * const ref = &a
  ref=20;//内部发现ref是引用，自动转换成*ref=20

效果与地址传递相同，能够修改实参，简化了地址传递（指针的使用）

void swap(int &x,int &y){……;
}
//实际上为取别名，将a->x,b->y
swap(a,b);

引用可以作为函数的返回值存在

• 不能返回局部变量的引用

  int& test(){int a=100;
      return a;
  }

• 函数调用能够作为左值使用（如果函数做左值，则必须返回引用）

  int& test(){static int a=100;
      return a;
  }
  test()=1000;

防止误操作，修改实参

int &ref=10;//错误，引用本身需要一个合法的内存空间
const int& ref =10;//正确，编译器自动优化代码
ref = 100;//错误，加入const后不可以修改变量


void show(const int& x){x=10;//不能够改变
}

int fun(int a=10,int b=20)形参中可以有默认参数

• 若有传入数据，则用传入的数据；否则用默认值
• 若某位置有参数，从这位置往后必须有默认值
• 函数的声明中有默认值，函数的实现就不能有默认值

void fun(int),只有数据类型

• 调用时需要有参数调补该位置，可以有默认参数

函数名相同，提高复用性

• 条件
  • 同一个作用域
  • 函数名相同
  • 参数类型不同 or 个数不同 or 顺序不同（返回值类型不同不是条件）
• 注意事项

  • 引用作为重载的条件

    //不同情况
    void fun(int &a){}  int a=10;fun(a);
    void fun(const int &a){}   fun(10);

  • 重载碰到默认参数
    会出现二义性

    void fun(int a,int b=10){}
    void fun(int a){};
    fun(10);//此时两个都可以调用，分不清

• 程序运行时产生的数据属于临时数据，程序一旦运行结束都会被释放，而通过文件可以将数据持久化
• 对文件的操作需包含头文件
• 文件类型
  • 文本文件：以文本的ASCII码的形式存储
  • 二进制文件：以文本的二进制形式存储
• 操作文件三大类
  • ofstream：写操作
  • ifstream：读操作
  • fstream：读写操作

• 写文件

  • 包含头文件：#include
  • 创建流对象：ofstream ofs;
  • 打开文件：ofs.open("文件路径",打开方式);
    没写绝对路径的话，生成在当前目录
  • 写数据：ofs<<"写入的数据";
  • 关闭文件：ofs.close();

• 文件打开方式
  可以配合使用，利于|操作符

  打开方式	解释
  ios::in	为读文件而打开文件
  ios::out	为写文件而打开文件
  ios::ate	初始位置，文件尾
  ios::app	追加方式写文件
  ios::trunc	如果文件存在先删除，再创建
  ios::binary	二进制方式

• 读文件

  • 包含头文件：#include

  • 创建流对象：ifstream ifs;

  • 打开文件并判断是否成功打开：

    ifs.open("文件路径",打开方式);
    if(!ifs.is_open(){cout<<"文件打开失败"<

    没写绝对路径的话，生成在当前目录

  • 读数据：四种方式

  • 关闭文件：ifs.close();

• 读数据的四种方式

  • 第一种

    char buf[1024] = {0};
    while(ifs>>buf){cout<

  • 第二种

    char buf[1024] = {0};
    while(ifs.getline(buf,sizeof(buf))){cout<

  • 第三种

    string buf;
    while(getline(ifs.buf)){cout<

  • 第四种（不推荐）

    char c;
    while( (c=ifs.get())!= EOF ){//EOF 表示end of file
        cout《《
    }