啥意思,这个循环是?每次给P分配一个字节,然后把那个位置写入0?但是0是整数吧?他需要四个字节???这和0地址有什么关系……啊啊啊啊啊
一,字符串操作
1.0 字符数组 补
0标志字符串的结束,但它不是字符串的一部分
计算字符串长度的时候不包含这个0字符串以数组的形式存在,以数组或指针的形式访问更多的是以指针的形式
string.h里有很多处理字符串的函数
//字符数组
char word[] = { 'h','e','l','l','o', };
//字符串
char w[] = { 'h','e','l','l','0','\0' };
//字符串就是以0或‘\0'结尾的字符数组,注意‘0’是0字符
//0表示的是INT 要四个字节,\0一定是一个字节的东西
char* str = "hello";
//STR是指针,指向了数组{HELLO}
char word[] = "hello";
//字符数组,内容是HELLO
char line[10] = "hello";
//十个字符的字符数组,放了5个字符,占6个空间,包括结尾的0
//字面量表达之后,编译器自动生成的
一定要有结尾的0才是字符串
两串相邻的自动连成一串
printf("的份额服务"
"feefwefwevwf\n");
printf("的份额服务\
feefwefwevwf\n");
//会把前面回退一起输出,\表示输出没有结束
C语言的字符串是以字符数组的形态存在的
不能用运算符对字符串做运算
通过数组的方式可以遍历字符串
唯一特殊的地方是字符串字面量可以用来初始化字符数组
以及标准库提供了一系列字符串函数
1.1 字符串变量 补
int main(int argc,char const *argv[]) {
int i = 0;
char* s = "hello world";
//s[0] = 'b';错误
char* s2 = "hello world";
printf("%s\n", s);
printf("i=%p\n", &i);
printf("s=%p\n", s);
printf("s2=%p\n", s2);
printf("here,s[0]=%c\n", s[0]);
//S,S2地址一样,I【本地变量】和S不在一个地方
//S的地址很小,只读,代码端
//实际上是CONST CHAR*S
char s3[]= "hello world";
printf("s3=%p\n", s3);
printf("i=%p\n", &i);
s3[0] = 'b';
printf("%s\n", s3);
//可以修改
return 0;
}
指针还是数组,CHAR* S CHAR S[ ]
指针——1,反正就是用来输出一下,2,作为函数参数,3,分配动态空间【空间是MALLOC得到的,肯定是指针??】
1.3 字符串输入输出 补
#include<stdio.h>
int main(int argc,char const *argv[]) {
char word[8];
char word2[8];
scanf("%s", word);
scanf("%s", word2);
printf("%s##\n%s##\n", word, word2);
//SV不行,回车和空格都是间隔符,和TAB
//越界危险
char aa[8];
scanf("%7s", aa);
printf("%s##\n", aa);
//最多读7个东西 ,剩下的给下一个%s?
return 0;
}
常见错误:1,不初始化指针直接使用,CHAR*STRING,
2, 空字符串,char buttur[]="";=='\0\ ,长度只有1
呵呵,我不知道,并且没看懂顶楼大神的高清图 ,大柳树下,互联网大哥的图
1.4 字符串数组
#include<stdio.h>
int main() {
//cha**a ——》A是一个指针,指向另一个指针,这个指针指向一个字符(串)
//char a[][]//第二维一定要有确定的值
//a[0] ——》char[10],此时需要注意每一个字符串的长度
char a[][10] = {
"hello",
"word",
"weewdfwegweh"//太长了
};
return 0;
}
#include<stdio.h>
int main() {
//a[0]——》char*
char *a[] = {
"hello",
"word",
"weewdfwegweh"
};
return 0;
}
1.2.1 月份
#include<stdio.h>
int main() {
char* mouth[] = {
"januaray",
"february",
"march",
"april",
"may",
"june",
"july",
"august",
"september",
"october",
"november",
"december",
};
int i = 0;
scanf_s("%d", &i);
printf("%s\n", mouth[i - 1]);
return 0;
}
1.2.2 程序参数
#include<stdio.h>
int main(int argc, char const* argv[]) {
//两个参数,整数,字符串数组
//整数告诉我们字符串数组有多大,数组带入函数需要另一个参数告诉大小
int i;
for (i = 0; i < argc; i++) {
printf("%d:%s\n", i, argv[i]);
}
//什么?0:.a.out,跟上点东西?会被ARGC ARGV读到
//第一个函数,就是ARGC的0,就是执行的时候读到的命令的名字
//或者说输入的可执行文件的名字
return 0;
}
不能说毫不相干,只能说南辕北辙,但是突然发现这个是文件的保存地址……啊啊啊
啊啊啊啊啊啊啊啊啊啊啊啊没懂
1.2.3 BUSY BOX 没懂
……………………搜了扫两眼
1.5 PUTCHAR & GETCHAR
#include<stdio.h>
int main()
{
int ch;
while((ch=getchar())!=EOF){
putchar(ch);
}
printf("EOF\n");
return 0;
}
#include<stdio.h>
int main(int argc, char const* argc[])
//运行不了,会说const char**与int的间接寻址级别不同?
//打错字了而已,char const*argv[]
//putchar会把一个字符输出在标准输出上,但是输入的类型是INT类型
//返回的类型也是INT,成功返回1,失败EOF(宏,值是-1)
//getchar返回从标准输入读到的一个字符,类型也是INT
//通过返回EOF表示标准输入结束了
{
int ch;
while ((ch = getchar()) != EOF) {
putchar(ch);
}
//输入一个值,读到的如果不是EOF,输出CH
printf("EOF\n");
return 0;
}
//输入ctrl d结束了,但是没有输出EOF,只是强制循环结束,没有正确的让他知道,输入结束了
//继续输入还是可以进入循环,就是?没有进行下一步?
//输入CTRL Z,输入结束了,运行到了下一个语句?
//UNIC?需要输入CTRL D
行编辑,缓冲区,SHELL?大概就是两个命令就是不一样吧
二,字符串函数的实现
STRLEN,返回字符串长度
STRCMP,比较大小
STRCPY,拷贝
STRCAT,连接
STRCHAR,寻找一个字符
STRSTR,寻找一个字符串
2.1 STRLEN 长度
返回字符串长度
#include<stdio.h>
#include<string.h>
//写一个代替STRLEN,遍历字符串,知道读到最后的0,结束
int mylen(const char* s) {
int idx = 0;
while (s[idx]!='\0') {
idx++;
}
return idx;//没有就0了哦
}
int main() {
//strlen size_t strlen(const char*s)
//返回S的字符串长度(不包括结尾的0(\n),SIZEOF包括
//传入函数数组和指针是一样的,所以用指针表示了?
//CONST不希望修改数组,不修改字符串
char line[] = "hello";
printf("strlen=%lu\n", strlen(line));
printf("sizeof=%lu\n", sizeof(line));
printf("mylen=%lu\n", mylen(line));
//5 6
return 0;
}
2.2 STRCMP 比较
比较字符串大小
两种思路,数组思路,指针思路,编译器会做优化,可能会差不多?
#include<stdio.h>
#include<string.h>
//挨个字符对比,知道都是\0,还是相等,则相等
int mycmp(const char*s1,const char*s2) {
int idx = 0;
while (1) {
if (s1[idx] != s2[idx]) {
break;
}
else if (s1[idx] == '\0') {
break;
}
idx++;//都没有出现,继续下一个比较
}
return s1[idx]-s2[idx];//返回差值
}
int mycmp1(const char* s1, const char* s2) {
int idx = 0;
while (s1[idx] == s2[idx] && s1[idx] != '\0') {
idx++;
}
return s1[idx] - s2[idx];
}
int mycmp2(const char* s1, const char* s2) {
while (*s1 == *s2 && *s1 != '\0') {
*s1++;
*s2++;
}//注意是不等于‘/-’
return *s1 - *s2;
}
int main(int argc,char const *argv[]) {
char s1[] = "abc";
char s2[] = "abc";
printf("%d\n", strcmp(s1,s2));
//0.相等表示0
//if (strcmp(s1, s2) == 0) ,注意,相等的结果是0,不能直接作为判断条件
//S1==S2 这个比较永远FAULT,因为这个比较是他们是否是相同的地址,两个变量的地址永远不相同
char s3[] = "bbc";
printf("%d\n", strcmp(s1, s3));
//-1,S3>S1,比他大,因为A在字母表前面,B在字母表后面,所以A小
char s4[] = "Abc";
printf("%d\n", strcmp(s1, s4));
printf("%d\n", 'a' - 'A');
printf("%d\n", mycmp(s1, s4));//32
//男神的是32 32 ,我的是1 32,男神说不相等的时候,给出的是两个的差值??
//差值就是返回值
char s5[] = "abc ";
printf("%d\n", strcmp(s1, s5));
//-1,男神的是32!!!啊啊啊啊为什么!
printf("%d\n", mycmp(s1, s5));
//MYCMP输出的是-32!
printf("%d\n", mycmp1(s1, s5));
printf("%d\n", mycmp2(s1, s5));
return 0;
}
2.3 STRCPY 拷贝
拷贝字符串
编译器会把打码优化,所以不用强求自己一定把代码写成那样子……while (*dst = *src);一个空循环
//char*strcpy(char*restrict dst,const char*restrict src);
// (目的,源)(det,src)
//return dst;再参与其他计算
//char* sdt = (char*)malloc(strlen(src) + 1);
// strcpy(dst,src);
//动态分配,申请一块内存把某个位置的字符串复制过来,
//只包括字符的长度,不包括‘\0’的结尾的长度,还要加一!!!
#include<stdio.h>
#include<string.h>
char* mycpy(char* dst, const char* src) {
int idx = 0;
while(src[idx]){
dst[idx] = src[idx];
idx++;
}//=0的时候出循环了,所以0没有写进去
dst[idx] = '\0';
return dst;
}
//优化,src[idx]!='\0'——》src[idx]:不是0就进入循环
char* mycpy1(char* dst, const char* src) {
while (*src != '\0') {
*dst++ = *src++;
}
*dst = '\0';
return dst;
}
char* mycpy2(char* dst, const char* src) {
while (*dst = *src)
;
* dst = '\0';
return dst;
}
int main(int argc,char const *argv[]) {
char s1[] = "bbc";
char s2[] = "abc";
strcpy(s1, s2);//用于调用的参数太少?
printf("%s\n",s1);
return 0;
}
2.4 STRCHR 查询
//char* strchr(const char*s,int c)
//char* strrchr(const char*s,int c)
//从左边数第一次C出现的位置,返回的时指针
//从右边开始
//返回NULL,没找到,非NALL,找到了
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main(int argc,char const *argv[]) {
char s[] = "hello";
char* p = strchr(s, 'l');
printf("%s\n", p);
//LLO,返回一个指针,把后面的东西当作一个字符串输出,LLO
//找第二个,LO
p = strchr(p + 1, 'l');
printf("%s\n", p);
//找到之后把后面的东西复制出来
char* t = (char*)malloc(strlen(p) + 1);
strcpy(t, p);
printf("%s\n", t);
free(t);
//输出L之前的东西
char c=*p;//c=l
*p='\0';//找到的第二个L,*p=0;
char* t1=(char*)malloc(strlen(s)+1);//S所指的字符串就只有HEL了
strcpy(t1,s);//拷出来
printf("%s\n", t1);
free(t1);
*p='l';//不要忘记写回去
return 0;
}
char* strchr(const char* s,int c)
// 寻找单个字符
char* strstr(const char* s1,const char* s2)
// 寻找一个字符串
char* strcasestr(const char* s1,const char* s2)
//寻找的时候忽略大小写
2.5 STRCAT 连接 补
天杀的,看到这里才发现不对!!!!我要闹了,我都以为学完要关电脑了!!!原来时MOOC23年的那个C程序设计进阶不全,还得看14年的!啊啊啊啊我说怎么字符串开头就如此生硬,就突然就讲了!!!!
连着字符串的内容都要补!!我要闹了!!!
呵呵呵,笑发财,本小白刚知道字符数组和字符串
我!就!说!今天怎么学的懵懵懂懂的!!!啊啊啊啊
#include<stdio.h>
#include<string.h>
int mycat(char*a,const char*b){
int i=0;
for(i=0;a[i]!='\0';i++)
;
int t=0;
for(t=0;a[t]!='\0';t++)
;
int s=0;
for(s=0;s<=t;s++){
a[i]=b[s];
s++;
i++;
}
return *a;
}
int main(int argc, char const* argv[]) {
//char* strcat(char*restrict s1,const char*restrict s2);
//把S2拷贝到S1的后面
//S1必须有足够的空间
char a[]="halllo ";
char b[]="byebye";
strcat(a,b);
printf("%s\n",a);
mycat(a,b);
printf("%s\n",a);
return 0;
}
STRCPY和STRCAT都有安全问题,空间不足!
char* strncpy(char* restrict dst, cosnt char* restrict src, size_t n);
char* strncat(char* restrict s1, const char* restrict s2, size_t n);
int strncmp(const char* s1, const char* s2, size_t n);
能够CPY,CAT多少字符,多了就掐掉
对于CMP是,只比较前面N个字符
结束!!!我真的麻了