字符串与字符数组
字符串注意事项：
#include <stdio.h>
void main() {
//c 是一个一维字符数组，给部分元素赋值
char c[7]={'t','o','m'};
char str[4] = {'a','b','c','\0'};
char str2[] = {'j','a','c','k'}; // 这个后面系统也不会自动添加 '\0'
char str3[] = "Hello"; // 这个后面系统会自动添加 '\0'
//输出 c , 系统会这样处理
//1. 从第一个字符开始输出，直到遇到 \0 , 表示该字符串结束
printf("\n c=%s", c);
printf("\n str=%s", str); // abc?
printf("\n str2=%s", str2); // jack乱码
printf("\n str3=%s", str3); // Hello
getchar();
}
字符串的遍历
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void main() {
char greeting[] = "Hello";
int i;
int len = strlen(greeting); // len = 5
printf("\n greeting=%s", greeting);
printf("\nlen=%d", len); //5
printf("\n字符串第3个字符是=%c", greeting[2]); //l
printf("\n");
for(i = 0; i < len; i++) {//遍历
printf("%c ", greeting[i]); //H e l l o
}
system("pause");
}
字符指针
str是一个常量，
str=“hello tom"相当于开辟了一块空间，存放了"hello tom”，然后希望将str指向这一块空间，当然这是不可以的，因为str是一个常量。
指针入门
&ptr：指针所存放的地址
ptr：原数值所存放的地址
*ptr：ptr所指向空间里存放的值（原数值的地址）
//讲解指针的入门
#include <stdio.h>
void main() {
int num = 1;
//定义一个指针变量，指针
//说明
//1. int * 表示类型为 指针类型
//2. 名称 ptr , ptr 就是一个 int * 类型
//3. ptr 指向了一个 int 类型的变量的地址
int *ptr = #
//num的地址是多少
//说明1：如果要输出一个变量的地址，使用格式是 %p
//说明2: &num 表示取出num这个变量对应地址
printf("\nnum 的值=%d num 地址=%p", num, &num);
//1.指针变量，本身也有地址 &ptr
//2.指针变量, 存放的地址 ptr
//3.获取指针指向的值 *ptr
printf("\nptr 的地址是 %p ptr 存放的值是一个地址为 %p ptr 指向的值=%d", &ptr, ptr, *ptr);
getchar();
}
值传递和地址传递
#include <stdio.h>
int main() {
int num = 100;
int *p = #
int * p2 = p;
*p2 = 55;
printf("num=%d *p=%d *p2=%d ", num, *p, *p2); // 55 , 55 ,55
getchar();
}
指针的自增和自减运算
自增运算
#include <stdio.h>
const int MAX = 3;//常量
int main () {
int var[] = {10, 100, 200}; // int 数组
int i, *ptr; // ptr 是一个 int* 指针
ptr = var; // ptr 指向了 var 数组的首地址
for ( i = 0; i < MAX; i++) {
printf("var[%d] 地址= %p \n", i, ptr );
printf("存储值：var[%d] = %d\n", i, *ptr );
ptr++;// ptr = ptr + 1(1个int字节数); ptr 存放值+4字节(int)
}
getchar();
return 0;
}
自减运算
#include <stdio.h>
const int MAX = 3;
int main () {
int var[] = {10, 100, 200};
int i, *ptr;
/* 指针中最后一个元素的地址 */
ptr = &var[MAX-1]; // &var[2]
for ( i = MAX; i > 0; i--) {// 反向遍历
printf("ptr存放的地址=%p\n", ptr);
printf("存储值：var[%d] = %d\n", i-1, *ptr );
ptr--; // ptr = ptr - 1(1个int的字节数 [4个字节])
}
getchar();
return 0;
}
指针数组
#include <stdio.h>
const int MAX=3;
int main ()
{
int var[] = {10, 100, 200};
int i, *ptr[3];
for ( i = 0; i < MAX; i++)
{
ptr[i] = &var[i]; /* 赋值为整数的地址 */
}
for ( i = 0; i < MAX; i++) //指针数组来获取各个值
{
printf("Value of var[%d] = %d ptr[%d]本身的地址=%p \n", i, *ptr[i] , i, &ptr[i]); // 10, 100, 200
}
getchar();
return 0;
}
多重指针
#include <stdio.h>
int main () {
int var;
int *ptr; //一级指针
int **pptr; //二级指针
int ***ppptr; // 三级指针
var = 3000;
ptr = &var; // var 变量的地址赋给 ptr
pptr = &ptr;// 表示将 ptr 存放的地址，赋给 pptr
ppptr = &pptr; // 表示将 pptr 存放的地址，赋给 ppptr
printf("var的地址=%p var = %d \n", &var, var );// 0x1133 3000
printf("ptr 的本身的地址=%p ptr存放的地址=%p *ptr = %d \n", &ptr, ptr, *ptr );
printf("pptr 本身地址 = %p pptr存放的地址=%p **pptr = %d\n", &pptr, pptr, **pptr);
printf("ppptr 本身地址 = %p ppptr存放的地址=%p ***ppptr = %d\n", &ppptr, ppptr, ***ppptr);
getchar();
return 0;
}
传递值（或地址）给函数
#include <stdio.h>
void test2(int *p); //函数声明，接收int *
void main() {
int num=90;
int *p = # //将 num 的地址赋给 p
test2(&num); //传地址
printf("\nmain() 中的num=%d", num); // num = 91
test2(p); //传指针
printf("\nmain() 中的num=%d", num);// num = 92
getchar();
}
void test2(int *p) {
*p += 1; //*p 就访问 num的值
}
#include <stdio.h>
/* 函数声明 */
double getAverage(int *arr, int size); //函数声明
double getAverage2(int *arr, int size); //函数声明
int main ()
{
/* 带有 5 个元素的整型数组 */
int balance[5] = {1000, 2, 3, 17, 50};
double avg;
/* 传递一个指向数组的指针作为参数 */
avg = getAverage( balance, 5 ) ;
/* 输出返回值 */
printf("Average value is: %f\n", avg );
getchar();
return 0;
}
//说明
//1. arr 是一个指针，
double getAverage(int *arr, int size)
{
int i, sum = 0;
double avg;
for (i = 0; i < size; ++i)
{
// arr[0] = arr + 0
// arr[1] = arr + 1个int字节（4）
// arr[2] = arr + 2个int字节（8）
//...
sum += arr[i];// arr[0] =>数组第一个元素的地址 arr[1]
printf("\narr存放的地址=%p ", arr);
}
avg = (double)sum / size;
return avg;
}
double getAverage2(int *arr, int size)
{
int i, sum = 0;
double avg;
for (i = 0; i < size; ++i)
{
sum += *arr;
printf("\narr存放的地址=%p ", arr);
arr++; // 指针的++运算, 会对arr 存放的地址做修改
}
avg = (double)sum / size;
return avg;
}
返回指针的函数
请编写一个函数 strlong()，返回两个字符串中较长的一个。
#include <stdio.h>
#include <string.h>
char *strlong(char *str1, char *str2){ //函数返回的char * (指针)
printf("\nstr1的长度%d str2的长度%d", strlen(str1), strlen(str2));
if(strlen(str1) >= strlen(str2)){
return str1;
}else{
return str2;
}
}
int main(){
char str1[30], str2[30], *str; // str 是一个指针类型，指向一个字符串
printf("\n请输入第1个字符串");
gets(str1);
printf("\n请输入第2个字符串");
gets(str2);
str = strlong(str1, str2);
printf("\nLonger string: %s \n", str);
getchar();
return 0;
}
编写一个函数，它会生成 10 个随机数，并使用表示指针的数组名（即第一
个数组元素的地址）来返回它们。
#include <stdio.h>
int *func(){
//int n = 100;//局部变量, 在func 返回时，就会销毁
static int n = 100; // 如果这个局部变量是 static 性质的，那么n 存放数据的空间在静态数据区
return &n;
}
int main(){
int *p = func(); //func 返回指针
int n;
printf("okoook~~"); //可能是使用到 局部变量 int n = 100 占用空间
printf("okoook~~");
printf("okoook~~");
n = *p;
printf("\nvalue = %d\n", n);// 思考，是否能够输出100? 不一定
getchar();
return 0;
}
函数指针
#include <stdio.h>
//说明
//1. max 函数
//2. 接收两个int ,返回较大数
int max(int a, int b){
return a>b ? a : b;
}
int main(){
int x, y, maxVal;
//说明 函数指针
//1. 函数指针的名字 pmax
//2. int 表示 该函数指针指向的函数是返回int 类型
//3. (int, int) 表示 该函数指针指向的函数形参是接收两个 int
//4. 在定义函数指针时，也可以写上形参名 int (*pmax)(int x, int y) = max;
int (*pmax)(int x, int y) = max; //
printf("Input two numbers:");
scanf("%d %d", &x, &y);
// (*pmax)(x, y) 通过函数指针去调用 函数max
// 调用方式 2 pmax(x,y)
maxVal = (*pmax)(x, y);
printf("Max value: %d pmax=%p pmax本身的地址=%p\n", maxVal, pmax, &pmax);
getchar();
getchar();
return 0;
}
回调函数
使用回调函数的方式，给一个整型数组int arr[10] 赋10个随机数
#include <stdlib.h>
#include <stdio.h>
// 回调函数
//1. int (*f)(void)
//2. f 就是 函数指针 , 它可以接收的函数是 (返回 int ,没有形参的函数)
//3. f 在这里被 initArray 调用，充当了回调函数角色
void initArray(int *array, int arraySize, int (*f)(void)) {
int i ;
//循环10
for ( i=0; i<arraySize; i++) {
array[i] = f(); //通过 函数指针调用了 getNextRandomValue 函数
}
}
// 获取随机值
int getNextRandomValue(void) {
return rand();//rand 系统函数， 会返回一个随机整数
}
int main(void) {
int myarray[10],i; //定义一个数组和 int
//说明
//1. 调用 initArray 函数
//2. 传入了一个函数名 getNextRandomValue (地址), 需要使用函数指针接收
initArray(myarray, 10, getNextRandomValue);
//输出赋值后的数组
for(i = 0; i < 10; i++) {
printf("%d ", myarray[i]);
}
printf("\n");
getchar();
return 0;
}
空指针
#include <stdio.h>
void main() {
int *p = NULL; // p 空指针
int num = 34;
p = #
printf("*p=%d", *p); // 34
getchar();
}