《array》
arr.c
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[2][3];
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++)
printf("%p ", &a[i][j]); //验证二维数组连续性
}
printf("%p %d\n", a, sizeof(a)); //二维数组的总字节数
printf("%p %d\n", a[0], sizeof(a[0])); //单个行一维数组占用的字节数
printf("%p %d\n", a[1], sizeof(a[1]));
return 0;
}
二维数组地址打印验证其连续性，使用sizeof计算数组占用的内存空间数，验证二维数组是由一维数组组成，且其空间加和等于一维数组
arr2.c
二维数组初始化
#include <stdio.h>
int main(int argc, char *argv[])
{
//int a[2][3] = {{1, 6, 9}, {2, 8, 5}}; 1.全部初始化
//int a[2][3] = {{1, 6}, {2}}; 2.部分初始化
//int a[][3] = {{1, 6}}; 3.行数可以省略
int a[3][3] = {{1}, {2, 3}, {4}};
//int a[3][] = {{1}, {2, 3}, {4}}; 4. 声明时列数不能省略
int i, j;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++)
printf("%d ", a[i][j]);
putchar('\n'); //换行
}
return 0;
}
二维数组初始化，循环打印出二维数组中元素
arr3.c
打印杨辉三角
特点第一列和对角线都是1，和二维数组类比
重点：赋值和打印都要注意 i 和 j 的关系，否则会导致结果混乱。
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[10][10] = {{0}};
int i, j;
for (i = 0; i < 10; i++) { //循环赋值
a[i][0] = 1; //第一列都是1，比较特殊所以直接赋值
for (j = 1; j <= i; j++) //j是从1开始 打印左下角是j<=i,打印右上角是j>=i
a[i][j] = a[i-1][j-1] + a[i-1][j]; //元素行列的特点
}
q
for (i = 0; i < 10; i++) { //注意大括号的位置以及两种换行方式
for (j = 0; j <= i; j++)
printf("%-8d ", a[i][j]); //循环打印 使用-8d 即左对齐8位，不足补空格，不加-号就是右对齐
putchar('\n'); //putchar是输出字符的，而不是字符串，所以在单引号和双引号方面要注意
// printf("\n"); 在实际打印杨辉三角的程序中，使用printf输出正确，但使用putchar会导致结果混乱，还不明白什么原因，最好使用printf输出
}
return 0;
}
demo1.c
#include <stdio.h>
int main(int argc, char *argv[])
{
//int i = 6, a[i];
int a[6] = {1, 4, 5}, i, n; //一维数组初始化 1.数组不初始化，其元素值为随机数 2.对static数组元素不赋初值，系统会自动赋以0值 3.只给部分数组元素赋初值，其他默认为0 （图片举例） https://i.328888.xyz/2023/04/12/iBjCgV.png
int b[] = {3, 4, 7, 8, 1, 0};
n = sizeof(b) / sizeof(int);
for (i = 0; i < n; i++) // 数组不做越界检查，注意循环次数的限制
//printf("%p %d ", &a[i], a[i]);
printf("%p %d\n", &b[i], b[i]); // 数组元素地址是连续递增的
//a = a + 1; // 数组名表示内存首地址，是地址常量，不能改变
printf("%p\n", a); // 数组名表示内存首地址，可以利用sizeof计算出数组所占字节（内存空间大小）
printf("%d\n", sizeof(a));
return 0;
}
一维数组的初始化，利用 sizeof 计算出数组元素的个数，循环打印出数组元素的地址以及数组元素
细节点分析：
//数组必须先定义后使用，数组元素表示形式，数组名[下标] （其中，下标可以是常量或整型表达式）
int a[10];
printf("%d",a); //数组元素输出要使用循环，只能逐个引用数组元素，不能一次引用整个数组 （×）
for(j=0; j<10; j++)
printf("%d\t",a[j]); //正确使用循环输出一维数组
max.c
寻找二维数组中最大值且输出其行列 （重要）
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[2][3] = {{2, 5, 8}, {21, 56, 9}};
int i, j, row, column;
row = column = 0;
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++) {
if (a[row][column] < a[i][j]) { //用第一个数和其他所有元素比较，遇到更大的数，则将其行列赋值
row = i;
column = j;
}
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++)
printf("%5d ", a[i][j]);
putchar('\n');
}
printf("max=%d %d %d\n", a[row][column], row, column);
return 0;
}
确定需要定义的变量：二维数组，输出循环需要两个变量 i , j , 输出行列需要两个变量 row、column
第一个循环进行比较，用第一个数和其他所有数一个一个进行比较，遇到大的数，将其行列值赋给row 和 column
第二个循环输出二维数组的值
最后实现功能打印出最大的数，并且输出其行列
sort.c
冒泡排序（分析思路掌握）
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[] = {3, 4, 17, 8, 31, 2, 9, 15}, n, i, j;
int t;
n = sizeof(a) / sizeof(int);
for (i = 0; i < n-1; i++) { //比较的回数
for (j = 0; j < n-1-i; j++) { //数组中元素两两比较
if (a[j] > a[j+1]){ //注意交换的理由是前一个数比后一个数大，交换后才能继续和后面的数比较，最终才能选出最大的数
t = a[j]; //从小到大排序，前一个数大于后一个数就交换
a[j] = a[j+1];
a[j+1] = t;
}
}
}
for (i = 0; i < n; i++)
printf("%d ", a[i]); //交换完成后，输出数组排序后的值
puts(""); //字符串输出空格 双引号
return 0;
}
一维数组冒泡排序，有几个元素排序几次
一维数组的冒泡排序，一趟一趟比较，每次只比较相邻的两个数，一次找出从大到小的数，然后按照从小到大的顺序输出
确定变量：一维数组，用 sizeof 计算出数组中元素的个数，比较的趟数以及每趟比较的次数，交换的中间变量，
整体思路 ：先循环比较，最后循环输出数组的值
n : 元素个数 一维数组下表从零开始，所以一维数组下标此刻应该为 a[ n - 1 ] , 循环到次数使用的是一维数组的下标 应该为 i < n - 1;
i : 排序的趟数 j 是每趟排序的次数
第一次循环比较出最大的元素，排除一个，所以是 n - 1 次，后面依次类推
冒泡排序一维数组，记住每次比较的次数就是n - 1 - i ;
前一个数大于后一个数的情况下，两个数交换
编程，先搞清楚什么事，确定逻辑，然后再动手，先确定主线，再优化细节（确定逻辑，主线，细节）
《string》
demo1.c
字符数组
和一维数组联系
#include <stdio.h>
int main(int argc, char *argv[])
{
char arr1[] = {'a', 'b', 'c'}; //1.初始化：逐个字符赋值
char arr2[6] = {'d', 'e', 'f'};
printf("arr1:%s %p\n", arr1, &arr1[2]); //打印出来数据不准确，当使用%s来输出一个字符数组内容的时候，前提是数组中本身应该含有'\0',或者是一个字符串，否则两个数组之间的地址是连着的，编译器不做任何检查，会顺序打印出下一个字符数组的数据，导致程序错误（重要）
printf("arr2:%s %p\n", arr2, arr2); //C语言中无字符串变量，用字符数组处理字符串 ，结束标志是'\0'.
#if 0 // 段注释语句
int i, n;
n = sizeof(arr1) / sizeof(char); //2.计算数组中元素
for (i = 0; i < n; i++)
putchar(arr1[i]); //3.字符数组输出
//printf("%c ",arr1[]); 这两种输出方式是等价的，字符数组中是字符则可以利用字符putchar或%c(printf),字符数组是字符串，利用 %s
putchar('\n');
n = sizeof(arr2) / sizeof(char);
for (i = 0; i < n; i++)
putchar(arr2[i]);
putchar('\n');
#endif
return 0;
}
字符数组初始化及打印出数组字符和数组地址，使用循环分别打印出数组的元素
demo2.c
字符串
和二维数组联系
（不理解）
#include <stdio.h>
int main(int argc, char *argv[])
{
char fruit[][20] = {"banana", "apple", "strawmerry", "watermelen"}; //字符串二维数组初始化
int i, j, n, m;
n = sizeof(fruit) / sizeof(fruit[0]); //计算有几个字符串
m = sizeof(fruit[0]) / sizeof(char); //计算每个字符串中有几个元素
// 这个地方不明白为什么可以直接利用 fruit[0] 代表其他字符串的长度
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++)
putchar(fruit[i][j]); //二维数组
putchar('\n');
}
return 0;
}
变量：字符串二维数组，循环打印的两个变量，含有的字符串个数计算，以及每个字符串中元素个数的计算
demo3.c
上下两个程序关联性：上面按照二维数组打印出字符数组中的值，下面用一维数组打印出字符数组中的值
#include <stdio.h>
int main(int argc, char *argv[])
{
char fruit[][20] = {"banana", "apple", "strawmerry", "watermelen"};
int i, n;
n = sizeof(fruit) / sizeof(fruit[0]);
for (i = 0; i < n; i++)
printf("%s\n", fruit[i]); //一维数组
return 0;
}
字符串数组初始化，计算出字符串数组中字符串的个数，利用循环打印出字符串
demo4.c
字符数组逆序输出 （掌握利用角标直接逆序这种思路）
#include <stdio.h>
int main(int argc, char *argv[])
{
char arr[] = "welcome"; //字符数组以字符串形式初始化
int i, n;
n = sizeof(arr)/sizeof(char);
for (i = n-1; i >= 0; i--)
putchar(arr[i]); //直接逆序输出
putchar('\n');
return 0;
}
demo5.c
逆序输出用户输入的字符串（重要）
#include <stdio.h>
#include <string.h> //使用字符串函数头文件
#define N 20
int main(int argc, char *argv[])
{
//char arr[] = "welcome";
//在数组已经如上初始化了的情况下，可使用 n = sizeof(arr)/sizeof(char); 来计算字符串的长度
//但如果是计算用户输入字符串的长度需要调用函数
char arr[N] = {0};
int i, n;
printf("Please input a string:");
gets(arr); // 用户输入字符串逆序输出
n = strlen(arr); //计算字符串长度
for (i = n-1; i >= 0; i--)
putchar(arr[i]);
putchar('\n');
return 0;
}
变量定义，输入字符，逆序输出字符
demo6.c
不利用字符串函数实现用户输入字符串逆序输出（重要）
#include <stdio.h>
#include <string.h>
#define N 20
int main(int argc, char *argv[])
{
char arr[N] = {0};
int i, j, n, ch;
printf("Please input a string:");
gets(arr); //用gets输入数据可以带空格，而scanf是以空格作为结束符的，需要一个一个字符输入
n = strlen(arr);
i = 0;
j = n-1; // i 和 j 指向字符串的头和尾
while (i < j) {
ch = arr[i];
arr[i] = arr[j];
arr[j] = ch;
i++;
j--; //字符数组中内容做交换
}
puts(arr);
return 0;
}
isalpha.c
看到这
检查是否为字母字符
#include <stdio.h>
#include <ctype.h> //头文件
int main(int argc, char *argv[])
{
int ch;
while ((ch = getchar()) != EOF) { //getchar中特殊的输入 ctrl + d 表示 EOF
if (isalpha(ch)) {
if (isupper(ch)) //是否是大写字母
printf("Upper:%c\n", ch);
if (islower(ch)) //是否是小写字母
printf("Lower:%c\n", ch);
}
if (isdigit(ch)) //是否为数字
printf("Digit:%d %c\n", ch-'0', ch); //输入的即使是数字，由于使用的是 getchar ,计算机也会识别为是字符(ASCII值) 2 ，所以需要将字符转化为数字，- '0'
putchar(ch);
}
return 0;
}
strcat.c
字符串拷贝
注意： 1. 字符数组1必须足够大
2. 连接前，两串均以 ‘\0’ 结束；连接后，串1的 ‘\0’ 取消，新串最后加 ‘\0’
#include <stdio.h>
#include <string.h>
#define N 100
int main(int argc, char *argv[])
{
char dest[] = "www.makeru";
char src[N] = ".com.cn";
strcat(dest, src);
puts(src);
puts(dest);
return 0;
}
strcat2.c
字符串连接函数
#include <stdio.h>
#include <string.h>
#define N 100
int main(int argc, char *argv[])
{
//char dest[] = {'a', 'b', 'c'}; //如果使用的不是字符串，但是使用了字符串连接函数，那么会导致输出结果混乱，会在检测到第一个 '\0' 时接着再去连接所需要连接的字符串
char dest[] = {'a', 'b', '\0'}; //正确的字符串初始化
char src[N] = ".com.cn";
strcat(dest, src);
printf("dest:%p src:%p\n", dest, src);
puts(src);
puts(dest);
return 0;
}
strchr.c
在字符串中查找某个字符
strrchr 反向在字符串中查找
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char s1[] = "abas$f$sf";
int ch;
ch = '$';
//printf("%p %p \n", s1, strchr(s1, ch));
//printf("%p %p \n", s1, strrchr(s1, ch));
printf("%d\n", strchr(s1, ch)-s1); // 4 确定字符在字符串中位置标号
printf("%d \n", strrchr(s1, ch)-s1); // 6 反向查找
return 0;
}
strcmp.c
字符串比较函数
功能：字符串比较
参数：两个字符串
规则：从左向右逐个字符比较（ASCII码），直到遇到不同字符或 ‘\0’ 为止
返值：返回 int 型整数
a、若字符串1 < 字符串2， 返回负整数 （-1）
b、若字符串1 > 字符串2，返回正整数 （1）
c、若字符串1 = 字符串2，返回零
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char s1[] = "ab";
char s2[] = "abc";
printf("%d\n", strcmp(s1, s2));
return 0;
}
strcpy.c
注意： 1. 字符数组1必须足够大
2. 拷贝时 ‘\0’ 一同拷贝
#include <stdio.h>
#include <string.h>
#define N 30
int main(int argc, char *argv[])
{
char src[] = "makeru";
char dest[N];
int i, n;
//strcpy(dest, src);
i = 0;
n = strlen(src);
printf("n=%d\n", n);
while ( i <= n) { //一个一个赋值 如果是 i < n ; 那就是没有拷贝 '\0' 会出现乱码，所以一定要是 i <= n;
dest[i] = src[i];
i++;
}
puts(src);
puts(dest);
return 0;
}
strlen1.c
man strlen 查看函数 手册
1.主要功能 √
2.主要描述
3.需要的头文件
4.参数的意义 √
5.返回值的意义 √
特点：1.排除结束符 ‘\0’
注意点： 1. 初始化时 ‘\0’ 位置
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
//char s1[10] = {'A', '0', 'B', '\0', 'C'}; //有一个字符串结束符，使用strlen ,只计算结束符之间的字符个数
char s1[] = "makeru"; //若没有给定数组长度，则使用strlen和sizeof看具体实际元素个数
printf("%d\n", strlen(s1));
printf("%d\n", sizeof(s1)/sizeof(char)); //使用sizeof计算，则最终得到的是给定的初始化的值，而不是实际字符数组中的有效元素个数，且包含 '\0' **(重要)**
return 0;
}
strlen2.c
- 初始化时包含转义字符，斜杠不算在内
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char s1[] = "\tab\nc\vd\\e"; //打印 \ 就是 \\
char s2[]= "\x69\141"; // \xhh 表示16进制 \ddd 表示八进制
printf("%d\n", strlen(s1)); // 9
printf("%d\n", sizeof(s1)/sizeof(char)); // 10
printf("\n%d\n", strlen(s2)); // 2
printf("%d\n", sizeof(s2)/sizeof(char)); // 3
puts(s2);
return 0;
}
strncat.c
附加指定长度字符串
#include <stdio.h>
#include <string.h>
#define N 30
int main(int argc, char *argv[])
{
char src[] = "makeru";
char dest[N] = ".com.cn";
strncat(dest, src, 4);
puts(src);
puts(dest);
return 0;
}
strncmp.c
比较指定长度字符串
忽略大小写比较字符串
#include <stdio.h>
#include <string.h>
#define N 30
int main(int argc, char *argv[])
{
char s1[] = "QUIT";
char s2[] = "quit";
printf("%d\n", strncmp(s1, s2, 4));
printf("%d\n", strcasecmp(s1, s2)); //忽略大小写比较字符串
return 0;
}
strncpy.c
复制指定长度字符串
#include <stdio.h>
#include <string.h>
#define N 30
int main(int argc, char *argv[])
{
char src[] = "makeru";
char dest[N] = ".com.cn";
strncpy(dest, src, 4);
puts(src); //结果：makeru
// make.cn 只拷贝n个内容，如果原串过长，只有部分内容被覆盖
puts(dest);
return 0;
}
strstr.c
查找字符串 vi当中查找字符串：在底行命令中：\dest
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char s[] = "how are you";
char subs[] = "are";
printf("%d\n", strstr(s, subs)-s);
return 0;
}
toupper.c
字符大小写转化
#include <stdio.h>
#include <ctype.h>
int main(int argc, char *argv[])
{
int ch;
while ((ch = getchar()) != EOF) {
if (isalpha(ch)) {
if (isupper(ch)) { // 检查是否为大写字母字符
ch = tolower(ch); // 转小写
}
else {
ch = toupper(ch); // 转大写
}
printf("%c\n", ch);
}
}
return 0;
}
3592
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
