一.函数
二.指针
demo：输入字符串输出重复字符串次数
一.函数
1.程序的入口函数
main.cpp 为了让阅读者知道我这里面写的是入口函数
2.将不同的功能模块用不用.h.cpp来封装
.h 头文件函数声明（不能实现：不能有{}）
.cpp.c 实现稳健 函数的具体实现{}
3.导入头文件进行使用
#include<stdio.h>
#include"calculator.h"
int main(){
printf("1+1=%d\n",add(1,1));
printf("2-1=%d\n",minus(2,1));
printf("2*2=%d\n",multiply(1,1));
printf("2/2=%d\n",devide(1,1));
return 0;
}
这是实现文件(具体这个函数的操作)
1.先导入需要实现的头文件
2.实现这个头文件里面的所有方法 calculator.cpp
#include"calculator.h"
//加法
int add(int a,int b){
return a+b;
}
//减法
int minus(int a,int b){
return a-b;
}
//乘法
int multiply(int a,int b){
return a*b;
}
//除法
int devide(int a,int b){
if(b==0){
printf("错误");
}else{
return a/b;
}
}
头文件里面声明函数calculator.h
#include<stdio.h>
int add(int a,int b);//加
int minus(int a,int b);//减
int multiply(int a,int b);//乘
int devide(int a,int b); //除
二.指针
1.什么是指针 作用
如果希望在函数之间传递数据(>1)给调用者
*：
①定义表明一个指针变量
②在使用过程中在前面加就是表示指针指向的值
&:取地址
2.指针的类型：int *p=&a（整形指针） ; char *p （字符指针）; int( *func)(int)（函数指针）;指针变量只能指向同种类型的地址
是一个变量，这个变量只能存地址，所占空间大小为8个字节。整形指针数组中每个元素都是整形数组，字符型指针数组中每个元素都是字符串
3.指针的值：就是指向的内存空间的首地址
注意：变量本身布占空间，他只是一种映射关系，映射到那个内存空间。
声明一个变量：比如int a；没给值，没有立刻分配内存空间，即没有地址
定义一个变量：比如int a=；则立刻分配了内存空间，并且赋值
4.指针指向的值（区域）：（星号p）
5.指针的运算：二级指针有两个(星号)
6.指针和数组
7.指针和函数
![CD}A7ZER4R_24%3(`~(4.png
#include<stdio.h>
int test(int a, int s){
a+1;
s+1;
return a+1;
}
a+1;
s+1;
return a+1;
}
//一个return只能返回一个值
int test2(int a, int s){
a+1;
s+1;
return a+1;
}
int main()
{
int money=10;//普通变量
int salary=10000;
int*pa;//指针变量
char*pb;
int a1[10];
int*a2[2];
cahr*a3[3];
int test(int a);
int(*test)(int a);
printf("%d\n",sizeof(pa)) ;
int temp=10;
int *p=&temp;
*p=20;
return 0;
}
指针储存的是地址
指向一个普通的变量：一级指针
直接改变 a=10 a的地址为0x100
间接改变 pa<=>0x100
pb==（0x200）=*（0x100）
pa为指针指向的变量
指向一个地址：二级指针
int a=20；
int pa=&a；
int （pc）=&pa；
int ** pd=&pc；
pd->访问pc的值
访问a: pa，pc，pd
普通指针变量
int *pa
常量指针（常量在前，不能变）
int a=20；
int b=30；
int const *pa=&a；
pa=50；->错误 不能改变指针只想的变量的值
pa=&b；->正确 可以改变指针的指向
指针常量（指针在前）数组就是指针常量
intconst pb=&a；
*pb=50；->可以 改变指针指向的变量的值
pb=&b；->错误 不能改变指针的指向
指向常量的常量指针
int const *const pc=&a；
*pc=50；错误 不能改变指针指向的变量的值
pc=&b；错误 不能改变指针的指向
int *ptemp=&a；
ptemp=20；->错误 指针变量只能存地址
指针（后续）
普通指针：int char 等平时常用的。
常量指针
比如int a = 20；int const *pa = &a：//const就是常量（命名根据const和 *pa的前后顺序看） 指向的变量的值不能变，但是它可以改变指向关系 比如你要再写 *pa=50；就不对。但是可以pa = &b；
比如查询学生信息，但是你不能改学生的信息，就用这个。
指针常量
int * const pb = &a；指向关系永远不能变，但是可以改变里面的值。比如不可以pb = &b，但是可以*pb = 50；数组就是一个指针常量。
指向常量的常量指针
int const const *pc = &a；或者const int *const pc =&a；就是什么都不能变，也不能改变指向，也不能改变值。
#include<stdio.h>
#include<stdlib.h>
void test (int a[]);
void test1 (int a[]);
//数组是一片连续的内存空间，而指针只是一个变量，只不过这个变量只能存地址 共同点：数组也可以用指针的方式去访问
int main (void){
int num [] = {1,2,3,4,5,6,7,8,9};//num(数组名）没有分配内存空间 因为sizeof（num） = 36；说明数组名本身没有分配内存空间
printf("%d\n",sizeof(num));//调用sizeof实际就是计算整个数组的所占的内存大小
int *p = num;
printf("%p\n",num);
printf("%p\n",num+1);//这个打印出来比上一个多4
printf("%p\n",&num + 1);//这个打印出来比第一个多整个数组的字节 也就是说（&a+1）就是指向下一个数组的起始地址。与（a+1）不同，（a+1）是下一个元素的起始地址。
//test(num);
// test1(num);
//num[0] = 30;
//num[1] = 20;
//*num + 1 = 21;//这样写不行 就相当于 1 + 1 = 21 了
/* *(num + 1) = 30;//注意加括号
printf("%d\n",num[0] );
printf("%d\n",num[0] );
printf("%d\n",num[1] );
printf("%d\n",*(num + 1) );
printf("%p\n",num +1);*/
//num是指针常量，不能改变指向关系，也就是说不能用数组名进行加减运算。比如不能写为num++；
//num+1不是加了整个数组的空间 num本质是地址，也就是p p+1那就是看指针的类型了。
/* *num+1 = 20;这个有如下两种可能
*(num+1) = 20;//这个是对的
(*num)+1 = 20;*///这是错的
*p++ = 20;//有如下两种情况
//(*p)++
//*(p++)// 这个是对的 *p++等价于*(p++)，p先与++结合。表示：取*p的值并返回，然后将p+1指向下一个地址 对指针进行++就是看指针的类型，整型指针加4，
//字符型加1，指针型加8.
int a = (*p)++;
int b = *(p++);
printf("-----%d %d\n",a,b);
char name[] = {'a','b','c','d'};
char *p1 = name;
char c = *(p++);
/[图片上传失败...(image-8b4726-1575551295365)]
ar c = *(++p);
printf("%c\n",c);
printf("%d\n",num[0]);
system("pause");
return 0;
}
void test (int *p){//只是把整个数组的第一个首地址传过去了
printf("%d\n",sizeof(p));
}
void test1 (int a[]){//只是把整个数组的第一个首地址传过去了
printf("%d\n",sizeof(a));
}
a+i2+j 是用指针访问数组中元素的方法 2是每一行有几列
比如a[3][2] = {{1,2},{3,4},{5,6}};访问第一个就是a[0][0]
例子：p[0*2+0]
指针与函数
#include <stdio.h>
/*
指针和函数的关系
作用：通过指针间接访问某个内存
*/
int add(int a, int b){
return a + b;
}
//定义一个函数 什么情况下参数是指针
//这个函数会不会改变传递过来的数据本身
//需要改变外部的值 就将这个变量定义为指针变量
void test(const int *pa, int *pb){
//(*pa)++;
(*pb)++;
printf("a = %d\n", *pa);
}
//函数接收数组时，必须知道数组元素个数
//函数里面是通过指针变量来接收数组的地址
//指针变量无法确定指向的内容的大小
//访问数组有两种方式
//1. num[3]
//2. *(num+3)
void test2(int *p, int count){
for (int i = 0; i < count; i++){
p[i]++; //p[i] += 1;
//*(p + i)++; //*(p + i) += 1;
}
}
int main(){
int a = 10;
int b = 20;
test(&a, &b);
printf("a:%d b:%d\n", a, b);
int num[5] = {1,2,3,4,5};
test2(num,5);
for(int i = 0; i < 5; i++){
printf("%d ", num[i]);
}
return 0;
}
