C语言作业摘录第三弹

Twisuki2025/5/6约 3107 字大约 10 分钟

C语言指针与字符串

指针

虽然一直对指针这个概念有所耳闻, 但这次才开始深入了解指针.

指针是一个特殊的变量, 它存储的是一个内存中的位置, 类型代表其位置的大小.

int a;
int *pa;

int a 定义了一个整型的变量a, int *pa则定义了一个指针pa, 它的类型是int, 也就是指向一个4字节的区域.

*pa = a;

这样pa指针就指向int a时在内存中开辟的区域了.

我们讨论一下指针在数组(尤其是char数组(C风格字符串))的应用.

int arr[8];

这样我们定义一个int类型数组, 它的长度是8, 也就是在内存中开辟了连续的4 * 8 = 32字节空间, arr[i]代表着一个4字节的空间.

int *p = arr;

这样定义指针p指向arr, 也就是开辟的32字节空间的起始点. 由于p类型为int, 所以p代表着从起始点开始的4字节空间.

\dots □□ ∣ a rr \underline{■□□□} □□□□□□□□□□□□□□□□□□□□□□□□□□□□ ∣ □□ \dots ↑ * p = a rr [0]

此时的p就代表着arr[0]的值.

printf("%d %d", arr[0], *p);

使用*p访问p指代的值, 可以得到和arr[0]相同的结果.

但如果printf("%d", p);, 将输出一串数字, 代表的是该数据在内存中的位置, 由于前面未知, 无法正常读取.

这时我们p ++;, 则p将指向下一个位置, 由于p是int类型指针, 则下一个位置也就是移动4个字节.

\dots □□ ∣ □□□□ \underline{■□□□} □□□□□□□□□□□□□□□□□□□□□□□□ ∣ □□ \dots ↑ * p = a rr [1]

同理, 我们可以让p一共自增7次, 当p指向最后一组时, 再让p自增, 由于内存是非常大的, p仍然可以指向一个新位置.

但该位置可能并未被定义或初始化, 我们无法确定p指向位置有什么数据, 写入数据有什么影响.

\dots □□ ∣ □□□□□□□□□□□□□□□□□□□□□□□□□□□□ \underline{■□□□} ∣ □□ \dots ↑ * p = a rr [7] \dots □□ ∣ □□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□ ∣ \underline{■□} \dots ↑ * p = ???

C风格字符串

对于C风格字符串, 也就是char数组, 我们可以用指针来方便的传参, 获取某位. 同时string.h标准库中的各个函数也都是接受/返回指针作为参数的.

char str[100] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
char *p = str;

char恰好只占1个字节, 所以我们画图表示, 也方便很多.

\dots □□ ∣ L □ o □ r □ e □ m □_□ i □ \dots \0 □ \dots □□ ∣ □□ \dots ↑ * p

我们可以使用p访问到'L'字符.

获取长度

字符串长度指的是从第一个字符到结束字符\0的长度, 而非数组长度(显然数组长度是大于实际长度的). 我们可以通过循环的方式来计算长度.

int len = 0;
char *p = str;
while (*p != '\0') {
    len ++;
    p ++;
}

\dots □□ ∣ L ■ o □ r □ e □ m □_□ i □ \dots \0 □ \dots □□ ∣ □□ \dots ↑ * p (l e n = 1)

p自增:

\dots □□ ∣ L □ o ■ r □ e □ m □_□ i □ \dots \0 □ \dots □□ ∣ □□ \dots ↑ * p (l e n = 2)

p一直自增到读取到结束符\0:

\dots □□ ∣ L □ o □ r □ e □ m □_□ i □ \dots \0 ■ \dots □□ ∣ □□ \dots ↑ * p (l e n = 56)

复制字符串

当我们定义好字符串, 可以直接定义新的指针指向该字符串, 创建浅拷贝, 然而这样几个拷贝直接会互相影响, 所以我们要创建新的空字符串, 之后将字符一个一个输入到新字符串中.

char a[100] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
char b[100];

char *pa = a;
char *pb = b;

while (*pa != '\0') {
    *pb = *pa;
    pa ++;
    pb ++;
}

我们定义一个指向a的指针pa, 之后用相同的方法遍历数组, 将每个值复制到指向b的指针pb中, 即写入b数组的对应位中.

a : \dots □ ∣ b : \dots □ ∣ ■□□ \dots \0 \dots □ ∣ □ \dots ↑ * p a * p b ↓ ■□□ \dots \0 \dots □ ∣ □ \dots

字符串比较

首先比较字符串长度, 若长度不相同, 则字符串不可能相等, 先比较长度可以省去部分算力.

而长度比较函数我们刚才已经写了出来, 不过现在没有现成的函数可以用, 我们还是直接用指针遍历字符串, 按位比较.

char a[100] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
char b[100] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";

char *pa = a;
char *pb = b;

while (*pa != '\0') {
    if (*pa != *pb) {
        printf("Not Equal");
        return 0;
    }
    pa ++;
    pb ++;
}
printf("Equal");

原理和上述字符串复制基本相同.

同理, 我们可以使用指针实现字符串查找某字符, 字符串查找字符串等.

`string.h`标准库函数

上式操作已经被封装到string.h标准库中, 我们可以直接使用标准库的函数进行操作.

strlen(str), 返回字符串str的长度.
strcpy(a, b), 将b字符串复制到a字符串中.
strcat(a, b), 将b字符串追加到a字符串后面.
strcmp(a, b), 比较a, b字符串的字典顺序.
strchr(a, c), 在字符串a中查找字符c.
strstr(a, b), 在字符串a中查找子字符串c.

上述函数中传入的字符串, 实际上都是指针, 表示的从指针位置开始到结束符\0的一段字符串.

示例:

#include <stdio.h>
#include <string.h>

int main () {
    char a[100] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
    char b[200] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";

    printf("%d\n", strlen(a)); // 56

    char c[100];
    strcpy(c, a);
    printf("%s\n", c); // Lorem ...

    strcat(b, a);
    printf("%s\n", b); // Lorem ... * 2

    printf("%d\n", strcmp("abc123", "abc124")); // "abc123" < "abc124", return -1

    return 0;
}

复杂操作接下来例题中再做讲解.

例题

统计字符串中英文字符, 数字字符和其他字符的数量

直接上代码, 前后略.

int alpha = 0, digit = 0, other = 0;
char *p = str;  

while (*p != '\0') {
    if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')) {
        alpha ++;
    } else if (*p >= '0' && *p <= '9') {
        digit ++;
    } else {
        other ++;
    }
    p ++;
}

使用ASCII字符的顺序来分类字符.

删除字符串中的指定字符

使用write和read两个指针来读写.

void delChar (char *p, char c) {
    char *write = p;
    char *read = p;
    
    while (*read) {
        if (*read != c) {
            *write = *read;
            write ++;
        }
        read ++;
    }
    *write = '\0';
}

read指针用于读取内容, 正常情况下, 它们同时移动.

当read指针读取到需要删除的字符时, write则停止移动, 这时read读取到内容, write会直接覆盖掉被删去的字符和它之后的位置.

同步读写:

* r \dots □ ∣ * w e a d ↓ L ore m i p s u m d o l or s i t am e t .\ □ ∣ □ \dots ↑ r i t e

读取到需要删除的字符(这里以空格为例):

* r \dots □ ∣ L ore m * w e a d ↓_i p s u m d o l or s i t am e t .\ □ ∣ □ \dots ↑ r i t e

这时仅read ++, write保持不动:

* \dots □ ∣ L ore m * w re a d ↓_i p s u m d o l or s i t am e t .\ □ ∣ □ \dots ↑ r i t e

之后write写入*read:

* \dots □ ∣ L ore m * w re a d ↓ \underline{i} i p s u m d o l or s i t am e t .\ □ ∣ □ \dots ↑ r i t e

接下来read和write继续前进, 覆盖字符串:

L ore m \underline{i} \hat{i} p s u m d o l or s i t am e t . L ore mi \underline{p} \overset{p}{^} s u m d o l or s i t am e t . L ore mi p \underline{s} \overset{s}{^} u m d o l or s i t am e t . L ore mi p s \underline{u} \overset{u}{^} m d o l or s i t am e t . L ore mi p s u \underline{m} \overset{m}{^} d o l or s i t am e t . * \dots □ ∣ L ore mi p s u m * w re a d ↓ \underline{m}_d o l or s i t am e t .\ □ ∣ □ \dots ↑ r i t e

这时read再次读取到空格, write再停止一步, 之后同步:

\dots □ ∣ L ore mi p s u m * w * re a d ↓ \underline{d}_d o l or s i t am e t .\ □ ∣ □ \dots ↑ r i t e L ore mi p s u m \underline{d} \hat{d} o l or s i t am e t . L ore mi p s u m d \underline{o} d \overset{o}{^} l or s i t am e t . L ore mi p s u m d o \underline{l} l \hat{l} or s i t am e t . L ore mi p s u m d o l \underline{o} l \overset{o}{^} r s i t am e t . L ore mi p s u m d o l o \underline{r} o \overset{r}{^} s i t am e t . L ore mi p s u m d o l or \underline{o} r^s i t am e t .

此时write指针再次等待.

L ore mi p s u m d o l or \underline{o} r^s i t am e t . L ore mi p s u m d o l or \underline{s} r \overset{s}{^} i t am e t . L ore mi p s u m d o l ors \underline{r} s \hat{i} t am e t . \dots\dots

最终:

L ore mi p s u m d o l ors i t am e t \underline{.} m e t \dot{^}

这时read再次移动, 得到结束符\0, 这时write再次移动, 写入结束符\0, 这时字符串变为:

L ore mi p s u m d o l ors i t am e t . \underline{\0} e t . \hat{\0}

现在字符串虽然后面扔有残留字符, 但由于倒数第4位处位结束符\0, 则说明该字符串到此处结束, 后面有无字符无所谓, 不会参与运算.

字符串循环移位

对于字符串str, 输入数字n, 将字符串里面的字符循环向左移动n位.
例如, 输入123456789 3, 则输出456789123.

首先, 我们先处理n, 对于一个长度为9的字符串, 若n = 9, 则无需处理; 若n = 10, 则相当于n = 1.

故先使n对字符串长度取模.

之后拆分字符串, 将后半部分先复制到新字符串中, 再追加前半部分, 返回(或使覆盖)新字符串.

代码如下:

void cyclicShift(char *ps,int n){
    int len = strlen(ps);
    n %= len;

    char newStr[N];
    ps += n;
    strcpy(newStr, ps);
    *ps = '\0';
    ps -= n;
    strcat(newStr, ps);
    strcpy(ps, newStr);
}

第一步取模部分无需讲解.

第二步创建字符串并复制后半部分, 这里先使指针移动n位, 从现在开始就是字符串后半部分了, 复制字符串到newStr.

s t r : □□□ * p s ↓ 现在的字符串 \underline{■□□□□□} \0 □□ \dots n e wSt r = "456789"

第三步追加前半部分, 这里需要将指针移动回去, 但是如果直接追加, 无法控制长度, 将一直追加到最后面, 变成456789123456789.

所以这里先将现在的位置写入终止符\0, 再将指针移动回去, 这样就只会追加前半部分了.

s t r : * p s ↓ 现在的字符串 \underline{■□□} \0 □□ \dots n e wSt r = "456789 \underline{123} "

单词统计

统计一行英文中单词的个数. 注意, 由于书写问题, 单词之间可能有多个空格, 标点和单词直接空格未知, 字符串前后可以有若干空格.
例如, 输入 This is my favorite movie., 输出5.

我们思考如何区分单词. 显然, 单词通过空格, 标点分割, 但上述说明中发现这些数目都不固定, 难以区分.

我们从前往后读字符串: 当由其他字符进入字母时, 这是一个单词的开始; 当从字母变成其他字符时(空格, 标点), 这是一个单词的结束; 而从字母到字母和字符到字符都说明不了什么.

所以我们只要统计字母变成其他字符的情况即可.

int wordCounter (char *ps) {
	int count = 0;
	int isAlpha = 0;
	
	while (*p != '\0') {
		if ((*ps >= 'a' && *ps <= 'z') || (*ps >= 'A' && *ps <= 'Z')) {
            isAlpha = 1;
        } else {
            if (isAlpha) count ++;
            isAlpha = 0;
        }
        ps ++;
	}
	if (isWord == 1) count ++;
	
	return count;
}

这里使用isAlpha存储是否为字母. 当读取到字母时, 令isAlpha = 1, 标记为字母; 当读取到非字母时, 若isAlpha, 即上一个标记的是字母, 则计数一个单词, 同时令isAlpha = 0, 标记为非字母;

循环结束后, 还要再次进行一次判断, 防止This is my favorite movie这样结尾没有字符的漏判.

C语言作业摘录 第三弹

C语言作业摘录第三弹