1.无参无返
void test1()
{

}
2有参无返
void test2(int a)
{

}
3.无参有返
int test3()
{

return 0;//返回结果
}
4.有参有返
int test4(int b)
{

    return b;//finally return a int number b
}

int main()
{
    test1();
    
    test2(100);
    
    int num1;
    num1=test3;

    int num2;
    num2=test(1000)// now is ecqual to b is 1000;

return 0;
}

函数分文件编写

****.h头文件----函数声明

****.cpp_写函数定义

（写函数声明时也要把<iostream> 和namespace加进去 namespace存疑）

源文件中写函数定义，要加#include " ****.h" <记得有双引号，表示是我们自己的>

指针

可以通过指针保存地址，这个地址存放着一个数据

定义指针

定义指针语法：
数据类型  * 指针变量名
int * p
记录地址
p = & a    //让指针p 记录变量a的地址

怎么使用指针

使用解引用的方式找到指针指向的内存

*p    //解引用，找到指针p指向内存的数据

指针占用的内存空间

32位操作系统中占4个字节

eg:int *p=&a

cout<<"size of (int *)="<<size of(int *)<<endl;

空指针

指针指向内存中编号0的空间

可以用于初始化指针变量，空指针指向内存无权限访问 (0-255系统占用了)

int *p=NULL;

野指针

指针变量p指向了非法内存空间

eg: int *p=(int *)0x1100;

const修饰指针

常量指针

const修饰指针指针指向可以修改，指向的值不可以修改

int a=10,b=10;
const int *p=&a;
//修改指针指向的内存空间
p=&b;    //让指针指向b
//修改指向的值——指针指向的内存空间的值不能修改
*p=200;    //操作错误

指针常量

const后面跟的值是常量 int * const p

指针的指向不可以改，指针指向内存空间的值可以修改

p=&b;    //让指针指向b——错误，指向不可以变
//修改指向的值——指针指向的内存空间的值可以修改
*p=200;    //现在p记录的内存空间的值变成了200

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

const int * const p = & a

指针指向和指向的值都不可变

指针和数组

利用指针访问数组

int arr[10]={1,2,3,4,5,6,7,8,9,10};
//访问第一个元素
1. arr[0]
//用指针  
2. int * p = arr; //这里arr就是数组首地址 
cout<<"用指针访问第一个元素 "<<*p<<endl;
//第二个
可以直接 p ++  指针向后偏移了四个字节，即：
 p ++ ；
cout<<"用指针访问第一个元素 "<<*p<<endl;
//在 C++ 中，当给一个指针添加一个值的时候，实际上添加的值是把这个值乘以指针引用的数据类型的大小。

指针和函数

值传递和地址传递

写一个交换函数,值传递——实参值不变
void swap(int x,int y){
    int tem=x;
    x=y;
    y=tem;
}

//交换地址——改变了实参的值
void swap2(int *p,int *q){
    int tem2=*p;
    *p=*q;
    *q=tem;
}

int main(){
    int a=10;
    int b=20;
//值传递
    swap(a,b);
//地址传递
    swap2(&a,&b);
}

结构体

用户自定的数据类型

定义和使用

语法： struct 结构体名｛成员列表｝

创建学生数据类型，创建具体学生语法
//1. struct 类型名称 ｛成员列表｝
struct student
{
   string name;
   int age;
   double score;
};
//创建具体学生
int main(){
    student stu1;
    stu1.name="bob";
    stu1.age=23;
    stu1.score=99;

struct student s2={"julia",23,100};

}
//定义时顺便创建
struct student
{
   string name;
   int age;
   double score;
}S1,S2,S3;    //这里S1,S2,S3就创建好了
--创建变量时，可以省略struct;

结构体数组

定义结构体
struct stu{
    string name;
    int age;
};
创建结构体数组
struct stu stuarry[10]={{值1},｛值2｝,｛值3｝};
遍历

结构体指针

操作符 ->

上面结构体
通过指针指向结构体变量
struct stu s1={"bubby",32};
通过指针访问结构体变量中的数据
struct stu *p=&s1
p->name;    //获取姓名

结构体嵌套

结构体中的成员是另一个结构体，被嵌套的如果在后面，要提前声明

结构体中的const

把函数中的形参改为指针可以减少占用的内存空间，而且不会复制新的副本出来；这个时候用const可以防止误操作

c++中随机数调用

rand()函数：返回一个非负整数，对应的头文件<cstdlib>

调用：randomNum = rand();

但是这样生成的是一个伪随机数(系统用函数生成的)

要提供一个随机数种子——调用srand函数
unsigned seed; // Random generator seed
srand(seed);

调用time函数
unsigned seed;  // Random generator seed
// Use the time function to get a "seed” value for srand
seed = time(0);
srand(seed);

将随机数的范围限制在 最小值 min 和最大值 max 之间的整数
number = (rand()%(maxValue - minValue +1)) + minValue;

number=rand()%10+1    //1~10

const int MIN_VALUE = 10;
const int MAX_VALUE = 18;
number = rand() % (MAX_VALUE - MIN_VALUE + 1) + MIN_VALUE;    //10〜18

C++笔记②

函数相关

函数定义

指针