#include<iostream>
using namespace std;
int main()
{
cout << "Hello World" << endl;

system("pause");
return 0;
}

在控制台中 输出 Hello world

变量的作用: 给一段指定的内存空间起名，方便反操作这段内存
方便我们管理内存空间
在内存中 我们有一个变量 10 ， 他的内存编号是十六进制的
例如: 0x0000 => 10 那我们要找这个内存 数据量一大 就比较麻烦了 都是16进制数
所以 我们起了个a 来作为变量名(方便管理内存空间)

常量: 用于记录程序中不可更改的数据
c++有两种方式
#define 宏常量 在文件上方定义表示一个常量
const所修饰的变量 在变量前+const 不可更改

#define day 7 //在头文件那边
coust int a = 10; //这个也不可修改 也会报错

数据类型: 整型

short 短整型 占用2字节
int 整型 4字节
long 长整型 Windows为 4字节 ， linux为4字节(32位操作系统),8字节(64位操作系统)
long long 长长整型 8字节

数据类型 浮点型

float 单精度浮点数 4字节
double 双精度浮点数 8字节
如果只写 float a = 3.14;
那这样 这个3.14这边是 double 类型的， 之后程序之后会进行一个转换，会把3.14转换成float
多了一个数据转换的过程

//科学计数法
float f1 = 3e2;//e的后面是一个正数 代表了 3* 10的2次方 代表300

float f2 = 3e-2;//e的后面是一个负数 代表了 3* 0.1的2次方 代表0.03

数据类型 字符
char ch = 'a';
只能写1个字符
c和c++中 字符变量只占一个字节
字符型变量并不是把字符本身放到内存中存储，而是将对应的ascll编码放入到存储单元

数据类型 字符串
char a[] = "123123";//c语言风格的字符串
string a = "bbb";//c++语言风格的字符串
#include<string>;//在使用c++风格的字符串的时候 要引用头文件

数据类型: bool 布尔

bool类型占 1个字节大小

sizeof 求出 数据类型占用内存大小
sizeof(数据类型/变量)

转义字符:不能显示出来的ASCll字符

数据的输入 cin 关键字
cin>>a 将控制台输入的 数字 赋值给a

数组：就是一个集合 里面存放了 相同的数据类型
数组是由连续的内存位置组成的;

一维数组
可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址

&取地址符号

二维数组 矩阵数组
int a[4][5] ;
为4 行 5 列的 二维矩阵数组

函数的定义
返回值类型 函数名 (参数列表){
函数体
return 表达式：
}
函数必须写在Main方法后面 要嘛就必须得声明函数 让编译器知道你有这个 函数的名称 以及如何调用函数

函数的分文件写法:
创建.h 后缀名的头文件
创建.cpp后缀名的源文件
在头文件中写函数的声明
在源文件中写函数的定义

这是在c++中写的顺序
我们在 .h 头文件声明的 那个方法 ，得有
#include<iostream>
using namespace std;
这两行
之后在你的 源文件那边 需要 引用你的 头文件

之后在我们Main方法那边 需要引用 头文件

指针
可以通过指针间接访问内存
内存编号都是从0开始记录的 用16进制数来表示
可以利用指针变量保存地址

int a= 10 ； 内存中是 10这个数据， 用a来找 编号0x0001;
我用一个 p 来存储 0x0001 这个地址 那这个 p 就是指针

用p这个指针来记录了 a的地址
int * p = &a;

如何使用指针
通过解引用的方式来找到指针指向的内存
指针前 加一个 * 号 ，代表解引用,代表你找到了 p指针存储在内存中的数据
*p

我们把 *p 改为1000 *p = 1000;
那内存中的地址中的数据也一样发生改变 a的数据也是1000;

指针也是一种数据类型 是指针变量
指针变量占的内存空间是多少？
在 32位操作系统下 都是 占用4个字节空间

在64位操作系统下 占用8个字节空间

空指针和 野指针
空指针: 指针变量指向内存中编号为0的空间
用途:初始化指针变量
//空指针
// 空指针用于给指针变量进行初始化
注意:空指针指向的内存是不可以访问的 ;
0~255 之间的内存编号是系统占用的 不允许更改,访问

int* p = NULL; //这个就是空指针的写法

这就是野指针，这种问题 不会被编译器所发现 编译会通过 但是会报错启动后
(读取访问权限异常)
在程序中要避免出现这种野指针
int* p = (int *) 0x1100;
cout << *p << endl;
0x1100 并没有什么开辟内存 你直接指向 就会有问题

const 修饰指针
const 修饰指针 ----常量指针
const 修饰常量 ----指针常量
const 既修饰指针， 又修饰常量

const 常量指针: \
就是在指针前面加 const
const int * p =&a;
当他是常量指针的时候 指针的指向的地址 可以修改 ， 但是 指针指向的值不可以修改
const int * p = &a;
*p = 20 ; //错误
*p = &b ; //正确

指针常量
int * const p = &a; //这就是 指针常量 在const后面的是 常量 那就是 指针常量
指针的指向 不可以改 但是 指向的值可以更改
*p = 20 ; //正确
*p = &b ; //错误

const 既修饰了指针 又修饰常量
const int * const p = &a;那就两个都不可以修改
*p = 20 ; //错误
*p = &b ; //错误

指针与数组
//利用指针访问数组中的元素
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//arr 就是 数组的首地址
cout << "第一个数据-------" << *p;
for (int i = 0; i < 10; i++)
{
cout << "第" << i+1 << "个数据是=" << *p<<endl;
p++;
}
p++;//指针像后偏移四个字节 ;

指针与函数
作用 利用指针作函数的参数 可以 修改 实参的值
其实就是 地址 传递 就是根据你传入的那个地址，利用内存地址 来 操作 那个 数据
最后 你外部的 那个被取地址的数据 如果在内部有改变 你外部也会发生改变 ;
void GetSum(int *a, int *b,int *c)
{
*c = *a + *b;
}
void Main()
{
int a = 10 ;
int b = 20 ;
int c = 0 ;
GetSum(&a,&b,&c);
}
根据上面的方法 最后输出的 c 就是 30 ;

结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

struct 结构体名 {};

实例化结构体的 三种方法

struct Student s1;
struct Student s1={变量1，变量2，变量3}// 必须一一对应
还有一个就是在 创建结构体的时候在后面直接创建
struct 结构体名 {}s1;

在创建结构体不可以省略 struct
在调用创建的时候可以省略 struct

结构体数组
struct 结构体名 数组名[个数] = {{} , {} , {} };

结构体指针

//创建结构体变量
Student s1 = {"结构体",18,100};
//通过 指针p 取得 结构体的地址
Student* p = &s1;
//通过 -> 来获得结构体中的属性
p->age;

如果要获得 指针指向的结构体的数据 那就需要 用 ->来获得他的数据

结构体嵌套结构体
1：
Student s1 = {"",18,100};
Teacher teacher = { 1,18,"老师",s1 };
2：
Teacher t1;
t1.age = 1;
t1.id = 2;
t1.name = 3;
t1.stu.age = 18; t1.stu.name = "学生"; t1.stu.score = 100;
两种方法都可以
在第二个方法中 必须在结构体中 创建 Student这个 结构体的时候 要加上 struct

在结构体中 const的使用场景
在 函数中 void Prist(const student * stu)
{
}
这样就不会在函数中修改这个结构体 ，如果要修改 就不要加const
防止误操作

将函数中的形参改为指针，可以减少内存空间 而且不会有多余的副本产生