C语言小练习（伍）

练习：

1. 利用指针变量将一个数组中的数据反向输出。

void renew(int *p,int len)
{
	for(int i = len - 1;i >= 0;i--)
	{
		printf("%d",*(p+i));
	}
}

int main()
{
	int a[5] = {1,2,3,4,5};
	int len1 = sizeof(a) / sizeof(int);
	
	renew(a,len1);
	
	return 0;
}

运行结果:

2. 利用指针变量计算下标为奇数的数组的和；

#include <stdio.h>

//计算下标为奇数和的函数
int fun(int *p,int len)
{
	int sum = 0;
	
	for(int i = 0;i < len;i++)
	{
		if(i % 2 != 0)
		{
			sum += *(p+i);
		}
	}
	return sum;
}

int main()
{
	int arr[8] = {1,2,3,4,5,6,7,8};
	int len1 = sizeof(arr) / sizeof(int);
	
	printf("计算的结果为:%d",fun(arr,len1));
	
	return 0;
}

运行结果:

3. 确认整型，字符型，浮点型指针变量的大小；

#include <stdio.h>

int main()
{
	int a = 5;
	float b = 6.0;
	
	int *p = &a;
	float *p2 = &b;
	const char *p3 = "c";
	
	printf("%zu,%zu,%zu",sizeof(p),sizeof(p2),sizeof(p3));
	
}

运行结果:

4. 利用指针变量输出字符数组中的所有字符。

#include <stdio.h>

int main()
{
	char s1[] = {'H','E','L','L','O',' ','W','O','R','L','D'};
	char *p = &s1[0];
	int len = sizeof(s1) / sizeof(char);
	for(int i = 0;i < len;i++)
	{
		printf("%c",*(p+i));
	}
	return 0;
}

运行结果:

5. 编写一个函数，用指针变量做参数，用于求出一个浮点型数组元素的平均值。

#include <stdio.h>
//计算平均值
float fun(float *p,int len)
{
	float sum = 0,avg;
	
	for(int i = 0;i < len;i++)
	{
		sum += *(p+i);
	}
	avg = sum / len;
	
	return avg;
}

int main()
{
	float arr[5] = {2.0,3.0,5.5,6.5,9.7};
	int len1 = sizeof(arr) / sizeof(float);
	
	printf("计算的结果为：%.2f",fun(arr,len1));
	
	return 0;
}

运行结果:

6. 编写函数,要求用指针做形参，分别实现以下功能：

（1）求一个字符串长度

（2）在一个字符串中统计大写字母的个数

（3）在一个字符串中统计数字字符的个数

#include <stdio.h>

//统计大写字母个数的函数
char fun(char *p,int len)
{
	int k = 0;
	for(int i = 0;i < len;i++)
	{
		if(*(p+i) >= 65 && *(p+i) <= 90) k++;
		
	}
	return k;
}
//统计小写字母个数的函数
char fun1(char *p,int len)
{
	int r = 0;
	for(int i = 0;i < len;i++)
	{
		if(*(p+i) >= 97 && *(p+i) <= 122) r++;
		
	}
	return r;
}
int main()
{
	char arr[9] = {'A','B','C','D','e','f','g','1','5'};
	int len1 = sizeof(arr) / sizeof(char);
	int n,n2;
	
	n2 = fun(arr,len1);
	n = len1 - fun(arr,len1) - fun1(arr,len1);
	
	printf("字符串的长度为%d,大写字母的个数为%d,数字字符的个数为%d",len1,n2,n);
	
	return 0;
}

运行结果:

7. 编写函数,要求用指针做形参，实现将二维数组(行列相同)的进行转置（行列数据互换）： int(*p) [N]

#include <stdio.h>

// 转置函数
void fun(int (*p)[3], int len1, int len2) 
{
    int temp[len1][len2]; // 临时矩阵来存储转置后的结果

    // 转置矩阵
    for (int i = 0; i < len1; i++) 
	{
        for (int j = 0; j < len2; j++) 
		{
            temp[j][i] = p[i][j]; // 将元素放入临时矩阵
        }
    }

    // 打印转置后的矩阵
    for (int i = 0; i < len2; i++) 
	{
        for (int j = 0; j < len1; j++) 
		{
            printf("%d ", temp[i][j]);
        }
        printf("\n");
    }
}

int main() 
{
    int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int len1 = sizeof(arr) / sizeof(arr[0]);
    int len2 = sizeof(arr[0]) / sizeof(int);

    printf("转置的结果为\n");

    fun(arr, len1, len2);

    return 0;
}

运行结果:

8. 编写函数,要求用指针做形参，实现统计二维数组上三角中的0 的数量：

#include <stdio.h>

int fun(int (*p)[4],int len1,int len2)
{
	int sum = 0;
	
	for(int i = 0;i < len1;i++)
	{
		for(int j = 0;j < len2;j++)
		{
			if(j > i && i == i && p[i][j] == 0)
			{
				sum++;
			}
		}
	}
	
	return sum;
}

int main()
{
	int arr[4][4] = {{1,2,3,0},{5,0,7,0},{9,0,1,0},{3,0,5,6}};
	int len1 = sizeof(arr) / sizeof(arr[0]);
	int len2 = sizeof(arr[0]) / sizeof(int);
	
	printf("上三角中0的个数为%d",fun(arr,len1,len2));
	
	return 0;
}

运行结果:

9. 编写一个指针函数，返回二维数组中最大元素的地址。

#include <stdio.h>

int *fun(int arr1[][3],int len1,int len2)
{
	int max = 0;
	int *fun1 = &max;
	
	for(int i = 0;i < len1;i++)
	{
		for(int j = 0;j < len2;j++)
		{
			if(arr1[i][j] > max)
			{
				max = arr1[i][j];
			}
		}
	}
	return fun1;
}
	
int main()
{
	int arr[2][3] = {1,2,3,4,5,6};
	int len1 = sizeof(arr) / sizeof(arr[0]);
	int len2 = sizeof(arr[0]) / sizeof(int);
	int *n = fun(arr,len1,len2);
	
	printf("最大元素%d的地址为：%p",*n,n);
	
	
	return 0;
}

运行结果:

1）定义整形变量i； int i;

2）p为指向整形变量的指针变量； int *p;

3）定义整形一维数组p,它有n 个整形元素； int p[n];

4）定义一维指针数组p,它有n个指向整形变量的指针元素； int p[n];

5）定义p为指向（含有n个整形元素的一维数组）的指针变量；*int(*p)[n];

6）p为返回整形函数值的函数； int p();

7）p为返回一个指针的函数，该指针指向整形数据； int* p();

8）p为指向函数的指针变量，该函数返回一个整形值； int(*p)();

9）p是一个指向整形指针变量的指针变量； int **p;

int i;

int *p;

#define n 10  
int arr[n];

int *p[n];

int (*p)[n];

int p();

int* p();

int (*p)();

int **p;

11. 动态申请一个具有10个float类型元素的内存空间，从一个已有的数组中拷贝数据，并找出第一次出现 12.35 的下标位置，并输出。

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <math.h> 
 
int main()  
{  
    float arr[10] = {1.2, 1.5, 1.6, 12.35, 0, 0, 0, 0, 0, 0}; // 初始化所有元素以避免未定义行为  
    float *p = (float*)malloc(10 * sizeof(float));  
  
    if (p == NULL) 
	{  
        printf("内存分配失败\n");  
        return 1;  
    }  
  
    // 拷贝所有元素，包括前四个  
    memcpy(p, arr, 10 * sizeof(float));  
  
    int index = -1; // 初始化下标为-1，表示未找到  
    for (int i = 0; i < 10; i++) 
	{  
        if (fabs(*(p + i) - 12.35) < 0.0001) 
		{ // 使用fabs函数比较浮点数  
            index = i;  
            break;  
        }  
    }  
  
    if (index != -1) 
	{  
        printf("12.35首次出现的下标为:%d\n", index);  
    } else {  
        printf("12.35未找到\n");  
    }  
  
    free(p);  
    p = NULL;  
  
    return 0;  
}

运行结果:

12. 动态申请一个整型数组，并给每个元素赋值，要求删除第3个元素；

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int *p = (int*)malloc(5 * sizeof(int));
	
	if(!p)
	{
		puts("内存分配失败!");
	}
	
	printf("请输入5个值\n");
	
	for(int i = 0;i < 5;i++)
	{
		scanf("%d",&p[i]);
	}

	for(int i = 2;i < 4;i++)
	{
		p[i] = p[i + 1];
	}
	
	int *temp = (int*)realloc(p,4 * sizeof(int));
	if(!temp)
	{
		printf("内存再分配失败!");
		free(p);
		return 1;
	}
	
	p = temp;

	printf("删除后的数组为\n");
	for(int i = 0;i < 4;i++)
	{
		printf("%2d",p[i]);
	}
	
	free(p);
	
	p = NULL;
	
	return 0;
}

运行结果:

13. 动态申请一个整型数组，并给每个元素赋值，要求在第4个元素后插入100；

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int *p = (int*)malloc(5 * sizeof(int));
	
	if(!p)
	{
		printf("内存申请失败!");
	}
	
	//数组赋值
	printf("请输入5个数\n");
	for(int i = 0;i < 5;i++)
	{
		scanf("%d",&p[i]);
	}
	
	//内存重新分配
	int *temp = (int*)realloc(p,6 * sizeof(int));	
	if(!temp)
	{
		printf("内存再分配失败!");
		
		free(temp);
		return 1;
	}
	p = temp;
	//存储值
	for (int i = 5; i > 4; i--) 
	{  
        p[i] = p[i - 1];
    }  
    p[4] = 100;
	//打印输出
	printf("插入后的数组为\n");
	for(int i = 0;i < 6;i++)
	{
		printf("%4d",p[i]);
	}
	//内存释放
	free(p);
	p = NULL;
	
	return 0;
}

运行结果: