从四个属性的角度来理解C语言的指针也许会更好理解

1.要说清楚指针是什么之前,先来看看如何从多维属性来理解普通变量,以及普通变量在内存中是什么样儿的。


比如现在有个整型变量:int a = 1;也就是说整型变量a的值是1

相信朋友们对这张图无任何异议,很简单嘛,a就是1,1就是a嘛。好了,我可以提炼出变量a的三个属性出来,分别是有用数据的名字,有用数据的值,有用数据的类型。

有用数据的名字,就是“a”;
有用数据的值,就是“1”;
有用数据的类型,就是“int”;

我之所以用“有用数据”这四个字来描述,是因为程序代码中会经常用到变量“a”,以及它的值“1”,还有它的类型“int”,那不就是有用的嘛,所以我就“有用数据”来描述变量a的三个属性。好了,我用下面的表示法来表示变量a的这三个属性:

变量a=(有用数据的名字,有用数据的值,有用数据的类型)

好了,假设变量a的地址是“0x380fe0”,则示意图2是从变量a的地址的角度来看变量a在内存中的存放形式:


我标记出变量a的地址是16进制的0x380fe0,a为1,也就是在内存地址为“0x380fe0”的地方放了一个值1。用C语言表示地址的术语来说就是“&a”等于“380fe0”。“&”是表示变量地址的意思。这张图相信朋友们也没有什么异议,对吧,都是很直观的东西。好,我又可以提炼出变量a的第4个属性,叫做“有用数据的地址”,也就是“&a”啦。至此,变量a的四个属性都齐全啦,如下:

变量a=(有用数据的地址,有用数据的名字,有用数据的值,有用数据的类型),具体到本例,就是:
变量a=(0x380fe0,a,1,int)

2.从四个属性来说明一般的整型变量在内存中的样儿,好了,下面我要放大招儿了,再说说从四个属性来理解指针变量,以及指针变量在内存中的样儿。


我定义一个指针变量:
int *p = NULL; 
p = 0x380fe0;
这两句代码朋友们也一定看的懂的,就是一个指针变量p的值用16进制来表示就是“0x380fe0”,这正好是变量a的地址



示意图3跟整型变量a的示意图1没任何区别,我也可以说p就是0x380fe0,0x380fe0就是p,跟变量a就是1,1就是a是一个道理。好,这里我提炼出指针p的第一个属性,叫做“指针自己的值”,指针变量p的值是0x380fe0,可不就是自己的值嘛!用如下表示发来表示就是:
指针p=(指针自己的值)

到此为止,朋友们应该都是无异议的,好,下面再来看“*p”是什么东西




指针变量p前面加个“*”就变成了“*p”。很多教材会说“指针变量p指向的值是1”,这说了等于没说,谁看的懂。加了星号后,*p就是a的等价物了,是a的别名了,也就是*p就是a,a就是*p。这样说大家应该都会看懂吧。好了,这里我可以提炼出指针变量p的剩余三个属性了,分别叫做”与星号结合名“,”有用数据的值“,”有用数据的类型“。
与星号结合名:就是”*“与指针p结合,变成*p;
有用数据的值:就是1;跟变量a的第三个属性一样;
有用数据的类型,就是int;跟变量a的第四个属性一样。
这样指针变量p的四个属性也齐全了,如下:
指针变量p=(指针自己的值,与星号结合名,有用数据的值,有用数据的类型)。在本例就是:
指针变量p=(0x380fe0,*p,1,int)。

3. 用变量a的四个属性与指针变量p的四个属性对比,一下子就能看出指针的本质了。
我整理下上述的伪代码:
int a = 1;//假设变量a的地址是0x380fe0
int *p = NULL;
p = &a;
再用我说的多维属性法分别来表示整型变量a和指针变量p,分别如下:
整型变量a=(有用数据的地址,有用数据的名字,有用数据的值,有用数据的类型)

指针变量p=(指针自己的值,与星号结合名,有用数据的值,有用数据的类型)

在本例中,它们各自的属性就是:
整型变量a=(&a的值,a,1,int)

指针变量p=(p的值,*p,1,int)
再细一点,就是:
整型变量a=(0x380fe0,a,1,int)

指针变量p=(0x380fe0,*p,1,int)
看出来了吗?看出来了吗》看出来了吗?它们的四个属性的含义是一一等价的,具体来说就是:
”&a“ 就是 ”p“.
”a“就是 ”*p“
”1“ 就是 ”1“
”int“ 就是 ”int“
这才是理解指针p的本质关键所在。
关于”&a“ 就是 ”p“我再说两句。同样是表示地址,”&a“是用了”&“和”a“两个字符的组合来表示的,而”p“就用了一个字符”p"来表示,这种字符数量上的不一致导致了很多人学指针时会犯晕!
关于”a“就是 ”*p“我也说两句。同样是表示整型变量的名字,这次”a“就用了一个字符”a“来表示,而”*p“用了字符“*”和”p"两个字符来表示,又是这种字符数量上的不一致又导致了很多人学指针时会犯晕!

说了这么多废话,其实就是为了说明指针变量的四个属性表示法,建议记住这四个属性表示法,以及与一般整型变量、字符变量等一般变量类型的四个属性之间的等价关系。当然了,别指望记住这四个属性你就理解指针了,该学习的还是要学习,该多写代码的还是要多写代码,我只是希望你记住四个属性后再学习指针时,不至于被指针碾压的那么惨。



来源:C语言编程技术分享

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。 一.简单匹配算法 先来看一个简单匹配算法的函数: int Index_BF ( char S [ ], char T [ ], int pos ) { /* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符 起存在和串 T 相同的子串,则称匹配成功,返回第一个 这样的子串在串 S 中的下标,否则返回 -1 */ int i = pos, j = 0; while ( S[i+j] != '\0'&& T[j] != '\0') if ( S[i+j] == T[j] ) j ++; // 继续比较后一字符 else { i ++; j = 0; // 重新开始新的一轮匹配 } if ( T[j] == '\0') return i; // 匹配成功 返回下标 else return -1; // 串S中(第pos个字符起)不存在和串T相同的子串 } // Index_BF 此算法的思想是直截了当的:将主串S中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较 S[i+j] 与 T[j],若相等,则在主串 S 中存在以 i 为起始位置匹配成功的可能性,继续往后比较( j逐步增1 ),直至与T串中最后一个字符相等为止,否则改从S串的下一个字符起重新开始进行下一轮的"匹配",即将串T向后滑动一位,即 i 增1,而 j 退回至0,重新开始新一轮的匹配。 例如:在串S=”abcabcabdabba”中查找T=” abcabd”(我们可以假设从下标0开始):先是比较S[0]和T[0]是否相等,然后比较S[1] 和T[1]是否相等…我们发现一直比较到S[5] 和T[5]才不等。如图: 当这样一个失配发生时,T下标必须回溯到开始,S下标回溯的长度与T相同,然后S下标增1,然后再次比较。如图: 这次立刻发生了失配,T下标又回溯到开始,S下标增1,然后再次比较。如图: 这次立刻发生了失配,T下标又回溯到开始,S下标增1,然后再次比较。如图: 又一次发生了失配,所以T下标又回溯到开始,S下标增1,然后再次比较。这次T中的所有字符都和S中相应的字符匹配了。函数返回T在S中的起始下标3。如图: 二. KMP匹配算法 还是相同的例子,在S=”abcabcabdabba”中查找T=”abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5] 和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根据T中T[5]==’d’的模式函数值(next[5]=2,为什么?后面讲),直接比较S[5] 和T[2]是否相等,因为相等,S和T的下标同时增加;因为又相等,S和T的下标又同时增加。。。最终在S中找到了T。如图: KMP匹配算法和简单匹配算法效率比较,一个极端的例子是: 在S=“AAAAAA…AAB“(100个A)中查找T=”AAAAAAAAAB”, 简单匹配算法每次都是比较到T的结尾,发现字符不同,然后T的下标回溯到开始,S的下标也要回溯相同长度后增1,继续比较。如果使用KMP匹配算法,就不必回溯. 对于一般文稿中串的匹配,简单匹配算法的时间复杂度可降为O (m+n),因此在多数的实际应用场合下被应用。 KMP算法的核心思想是利用已经得到的部分匹配信息来进行后面的匹配过程。看前面的例子。为什么T[5]==’d’的模式函数值等于2(next[5]=2),其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同,且T[5]==’d’不等于开始的两个字符之后的第三个字符(T[2]=’c’).如图: 也就是说,如果开始的两个字符之后的第三个字符也为’d’,那么,尽管T[5]==’d’的前面有2个字符和开始的两个字符相同,T[5]==’d’的模式函数值也不为2,而是为0。 前面我说:在S=”abcabcabdabba”中查找T=”abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5] 和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根据T中T[5]==’d’的模式函数值,直接比较S[5] 和T[2]是否相等。。。为什么可以这样? 刚才我又说:“(next[5]=2),其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同”。请看图 :因为,S[4] ==T[4],S[3] ==T[3],根据next[5]=2,有T[3]==T[0],T[4] ==T[1],所以S[3]==T[0],S[4] ==T[1](两对相当于间接比较过了),因此,接下来比较S[5] 和T[2]是否相等。。。 有人可能问:S[3]和T[0],S[4] 和T[1]是根据next[5]=2间接比较相等,那S[1]和T[0],S[2] 和T[0]之间又是怎么跳过,可以不比较呢?因为S[0]=T[0],S[1]=T[1],S[2]=T[2],而T[0] != T[1], T[1] != T[2],==> S[0] != S[1],S[1] != S[2],所以S[1] != T[0],S[2] != T[0]. 还是从理论上间接比较了。 有人疑问又来了,你分析的是不是特殊轻况啊。 假设S不变,在S中搜索T=“abaabd”呢?答:这种情况,当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=-1,意思是S[2]已经和T[0] 间接比较过了,不相等,接下来去比较S[3]和T[0]吧。 假设S不变,在S中搜索T=“abbabd”呢?答:这种情况当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=0,意思是S[2]已经和T[2]比较过了,不相等,接下来去比较S[2]和T[0]吧。 假设S=”abaabcabdabba”在S中搜索T=“abaabd”呢?答:这种情况当比较到S[5]和T[5]时,发现不等,就去看next[5]的值,next[5]=2,意思是前面的比较过了,其中,S[5]的前面有两个字符和T的开始两个相等,接下来去比较S[5]和T[2]吧。 总之,有了串的next值,一切搞定。那么,怎么求串的模式函数值next[n]呢?(本文中next值、模式函数值、模式值是一个意思。) 三. 怎么求串的模式值next[n] 定义: (1)next[0]= -1 意义:任何串的第一个字符的模式值规定为-1。 (2)next[j]= -1 意义:模式串T中下标为j的字符,如果与首字符 相同,且j的前面的1—k个字符与开头的1—k 个字符不等(或者相等但T[k]==T[j])(1≤k<j)。 如:T=”abCabCad” 则 next[6]=-1,因T[3]=T[6] (3)next[j]=k 意义:模式串T中下标为j的字符,如果j的前面k个 字符与开头的k个字符相等,且T[j] != T[k] (1≤k<j)。 即T[0]T[1]T[2]。。。T[k-1]== T[j-k]T[j-k+1]T[j-k+2]…T[j-1] 且T[j] != T[k].(1≤k<j); (4) next[j]=0 意义:除(1)(2)(3)的其他情况。 举例: 01)求T=“abcac”的模式函数的值。 next[0]= -1 根据(1) next[1]=0 根据 (4) 因(3)有1<=k<j;不能说,j=1,T[j-1]==T[0] next[2]=0 根据 (4) 因(3)有1<=k<j;(T[0]=a)!=(T[1]=b) next[3]= -1 根据 (2) next[4]=1 根据 (3) T[0]=T[3] 且 T[1]=T[4] 即 下标 0 1 2 3 4 T a b c a c next -1 0 0 -1 1 若T=“abcab”将是这样: 下标 0 1 2 3 4 T a b c a b next -1 0 0 -1 0 为什么T[0]==T[3],还有next[4]=0呢, 因为T[1]==T[4], 根据 (3)” 且T[j] != T[k]”被划入(4)。 02)来个复杂点的,求T=”ababcaabc” 的模式函数的值。 next[0]= -1 根据(1) next[1]=0 根据(4) next[2]=-1 根据 (2) next[3]=0 根据 (3) 虽T[0]=T[2] 但T[1]=T[3] 被划入(4) next[4]=2 根据 (3) T[0]T[1]=T[2]T[3] 且T[2] !=T[4] next[5]=-1 根据 (2) next[6]=1 根据 (3) T[0]=T[5] 且T[1]!=T[6] next[7]=0 根据 (3) 虽T[0]=T[6] 但T[1]=T[7] 被划入(4) next[8]=2 根据 (3) T[0]T[1]=T[6]T[7] 且T[2] !=T[8] 即 下标 0 1 2 3 4 5 6 7 8 T a b a b c a a b c next -1 0 -1 0 2 -1 1 0 2 只要理解了next[3]=0,而不是=1,next[6]=1,而不是= -1,next[8]=2,而不是= 0,其他的好象都容易理解。 03) 来个特殊的,求 T=”abCabCad” 的模式函数的值。 下标 0 1 2 3 4 5 6 7 T a b C a b C a d next -1 0 0 -1 0 0 -1 4 next[5]= 0 根据 (3) 虽T[0]T[1]=T[3]T[4],但T[2]==T[5] next[6]= -1 根据 (2) 虽前面有abC=abC,但T[3]==T[6] next[7]=4 根据 (3) 前面有abCa=abCa,且 T[4]!=T[7] 若T[4]==T[7],即T=” adCadCad”,那么将是这样:next[7]=0, 而不是= 4,因为T[4]==T[7]. 下标 0 1 2 3 4 5 6 7 T a d C a d C a d next -1 0 0 -1 0 0 -1 0 如果你觉得有点懂了,那么 练习:求T=”AAAAAAAAAAB” 的模式函数值,并用后面的求模式函数值函数验证。 意义: next 函数值究竟是什么含义,前面说过一些,这里总结。 设在字符串S中查找模式串T,若S[m]!=T[n],那么,取T[n]的模式函数值next[n], 1. next[n]= -1 表示S[m]和T[0]间接比较过了,不相等,下一次比较 S[m+1] 和T[0] 2. next[n]=0 表示比较过程中产生了不相等,下一次比较 S[m] 和T[0]。 3. next[n]= k >0 但k<n, 表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了,下一次比较S[m]和T[k]相等吗? 4. 其他值,不可能。 四. 求串T的模式值next[n]的函数 说了这么多,是不是觉得求串T的模式值next[n]很复杂呢?要叫我写个函数出来,目前来说,我宁愿去登天。好在有现成的函数,当初发明KMP算法,写出这个函数的先辈,令我佩服得六体投地。我等后生小子,理解起来,都要反复琢磨。下面是这个函数: void get_nextval(const char *T, int next[]) { // 求模式串T的next函数值并存入数组 next。 int j = 0, k = -1; next[0] = -1; while ( T[j/*+1*/] != '\0' ) { if (k == -1 || T[j] == T[k]) { ++j; ++k; if (T[j]!=T[k]) next[j] = k; else next[j] = next[k]; }// if else k = next[k]; }// while ////这里是我加的显示部分 // for(int i=0;i<j;i++) //{ // cout<<next[i]; //} //cout<<endl; }// get_nextval  另一种写法,也差不多。 void getNext(const char* pattern,int next[]) { next[0]= -1; int k=-1,j=0; while(pattern[j] != '\0') { if(k!= -1 && pattern[k]!= pattern[j] ) k=next[k]; ++j;++k; if(pattern[k]== pattern[j]) next[j]=next[k]; else next[j]=k; } ////这里是我加的显示部分 // for(int i=0;i<j;i++) //{ // cout<<next[i]; //} //cout<<endl; } 下面是KMP模式匹配程序,各位可以用他验证。记得加入上面的函数 #include <iostream.h> #include <string.h> int KMP(const char *Text,const char* Pattern) //const 表示函数内部不改变这个参数的值。 { if( !Text||!Pattern|| Pattern[0]=='\0' || Text[0]=='\0' )// return -1;//空指针或空串,返回-1。 int len=0; const char * c=Pattern; while(*c++!='\0')//移动指针比移动下标快。 { ++len;//字符串长度。 } int *next=new int[len+1]; get_nextval(Pattern,next);//求Pattern的next函数值 int index=0,i=0,j=0; while(Text[i]!='\0' && Pattern[j]!='\0' ) { if(Text[i]== Pattern[j]) { ++i;// 继续比较后继字符 ++j; } else { index += j-next[j]; if(next[j]!=-1) j=next[j];// 模式串向右移动 else { j=0; ++i; } } }//while delete []next; if(Pattern[j]=='\0') return index;// 匹配成功 else return -1; } int main()//abCabCad { char* text="bababCabCadcaabcaababcbaaaabaaacababcaabc"; char*pattern="adCadCad"; //getNext(pattern,n); //get_nextval(pattern,n); cout<<KMP(text,pattern)<<endl; return 0; } 五.其他表示模式值的方法 上面那种串的模式值表示方法是最优秀的表示方法,从串的模式值我们可以得到很多信息,以下称为第一种表示方法。第二种表示方法,虽然也定义next[0]= -1,但后面绝不出现-1,除了next[0],其他模式值next[j]=k(0≤k<j)的意义可以简单看成是:下标为j的字符的前面最多k个字符与开始的k个字符相同,这里并不要求T[j] != T[k]。其实next[0]也可以定义为0(后面给出的求串的模式值的函数和串的模式匹配的函数,是next[0]=0的),这样,next[j]=k(0≤k<j)的意义都可以简单看成是:下标为j的字符的前面最多k个字符与开始的k个字符相同。第三种表示方法是第一种表示方法的变形,即按第一种方法得到的模式值,每个值分别加1,就得到第三种表示方法。第三种表示方法,我是从论坛上看到的,没看到详细解释,我估计是为那些这样的编程语言准备的:数组的下标从1开始而不是0。 下面给出几种方法的例子: 表一。 下标 0 1 2 3 4 5 6 7 8 T a b a b c a a b c (1) next -1 0 -1 0 2 -1 1 0 2 (2) next -1 0 0 1 2 0 1 1 2 (3) next 0 1 0 1 3 0 2 1 3 第三种表示方法,在我看来,意义不是那么明了,不再讨论。 表二。 下标 0 1 2 3 4 T a b c A c (1)next -1 0 0 -1 1 (2)next -1 0 0 0 1 表三。 下标 0 1 2 3 4 5 6 7 T a d C a d C a d (1)next -1 0 0 -1 0 0 -1 0 (2)next -1 0 0 0 1 2 3 4 对比串的模式值第一种表示方法和第二种表示方法,看表一: 第一种表示方法next[2]= -1,表示T[2]=T[0],且T[2-1] !=T[0] 第二种表示方法next[2]= 0,表示T[2-1] !=T[0],但并不管T[0] 和T[2]相不相等。 第一种表示方法next[3]= 0,表示虽然T[2]=T[0],但T[1] ==T[3] 第二种表示方法next[3]= 1,表示T[2] =T[0],他并不管T[1] 和T[3]相不相等。 第一种表示方法next[5]= -1,表示T[5]=T[0],且T[4] !=T[0],T[3]T[4] !=T[0]T[1],T[2]T[3]T[4] !=T[0]T[1]T[2] 第二种表示方法next[5]= 0,表示T[4] !=T[0],T[3]T[4] !=T[0]T[1] ,T[2]T[3]T[4] !=T[0]T[1]T[2],但并不管T[0] 和T[5]相不相等。换句话说:就算T[5]==’x’,或 T[5]==’y’,T[5]==’9’,也有next[5]= 0 。 从这里我们可以看到:串的模式值第一种表示方法能表示更多的信息,第二种表示方法更单纯,不容易搞错。当然,用第一种表示方法写出的模式匹配函数效率更高。比如说,在串S=“adCadCBdadCadCad 9876543”中匹配串T=“adCadCad”, 用第一种表示方法写出的模式匹配函数,当比较到S[6] != T[6] 时,取next[6]= -1(表三),它可以表示这样许多信息: S[3]S[4]S[5]==T[3]T[4]T[5]==T[0]T[1]T[2],而S[6] != T[6],T[6]==T[3]==T[0],所以S[6] != T[0],接下来比较S[7]和T[0]吧。如果用第二种表示方法写出的模式匹配函数,当比较到S[6] != T[6] 时,取next[6]= 3(表三),它只能表示:S[3]S[4]S[5]== T[3]T[4]T[5]==T[0]T[1]T[2],但不能确定T[6]与T[3]相不相等,所以,接下来比较S[6]和T[3];又不相等,取next[3]= 0,它表示S[3]S[4]S[5]== T[0]T[1]T[2],但不确定T[3]与T[0]相不相等,即S[6]和T[0] 相不相等,所以接下来比较S[6]和T[0],确定它们不相等,然后才比较S[7]和T[0]。是不是比用第一种表示方法写出的模式匹配函数多绕了几个弯。 为什么,在讲明第一种表示方法后,还要讲没有第一种表示方法好的第二种表示方法?原因是:最开始,我看严蔚敏的一个讲座,她给出的模式值表示方法是我这里的第二种表示方法,如图: 她说:“next 函数值的含义是:当出现S[i] !=T[j]时,下一次的比较应该在S[i]和T[next[j]] 之间进行。”虽简洁,但不明了,反复几遍也没明白为什么。而她给出的算法求出的模式值是我这里说的第一种表示方法next值,就是前面的get_nextval()函数。匹配算法也是有瑕疵的。于是我在这里发帖说她错了: http://community.csdn.net/Expert/topic/4413/4413398.xml?temp=.2027246 现在看来,她没有错,不过有张冠李戴之嫌。我不知道,是否有人第一次学到这里,不参考其他资料和明白人讲解的情况下,就能搞懂这个算法(我的意思是不仅是算法的大致思想,而是为什么定义和例子中next[j]=k(0≤k<j),而算法中next[j]=k(-1≤k<j))。凭良心说:光看这个讲座,我就对这个教受十分敬佩,不仅讲课讲得好,声音悦耳,而且这门课讲得层次分明,恰到好处。在KMP这个问题上出了点小差错,可能是编书的时候,在这本书上抄下了例子,在那本书上抄下了算法,结果不怎么对得上号。因为我没找到原书,而据有的网友说,书上已不是这样,也许吧。说起来,教授们研究的问题比这个高深不知多少倍,哪有时间推演这个小算法呢。总之,瑕不掩玉。 书归正传,下面给出我写的求第二种表示方法表示的模式值的函数,为了从S的任何位置开始匹配T,“当出现S[i] !=T[j]时,下一次的比较应该在S[i]和T[next[j]] 之间进行。” 定义next[0]=0 。 void myget_nextval(const char *T, int next[]) { // 求模式串T的next函数值(第二种表示方法)并存入数组 next。 int j = 1, k = 0; next[0] = 0; while ( T[j] != '\0' ) { if(T[j] == T[k]) { next[j] = k; ++j; ++k; } else if(T[j] != T[0]) { next[j] = k; ++j; k=0; } else { next[j] = k; ++j; k=1; } }//while for(int i=0;i<j;i++) { cout<<next[i]; } cout<<endl; }// myget_nextval 下面是模式值使用第二种表示方法的匹配函数(next[0]=0) int my_KMP(char *S, char *T, int pos) { int i = pos, j = 0;//pos(S 的下标0≤pos<StrLength(S)) while ( S[i] != '\0' && T[j] != '\0' ) { if (S[i] == T[j] ) { ++i; ++j; // 继续比较后继字符 } else // a b a b c a a b c // 0 0 0 1 2 0 1 1 2 { //-1 0 -1 0 2 -1 1 0 2 i++; j = next[j]; /*当出现S[i] !=T[j]时, 下一次的比较应该在S[i]和T[next[j]] 之间进行。要求next[0]=0。 在这两个简单示范函数间使用全局数组next[]传值。*/ } }//while if ( T[j] == '\0' ) return (i-j); // 匹配成功 else return -1; } // my_KMP 六.后话--KMP的历史 [这段话是抄的] Cook于1970年证明的一个理论得到,任何一个可以使用被称为下推自动机的计算机抽象模型来解决的问题,也可以使用一个实际的计算机(更精确的说,使用一个随机存取机)在与问题规模对应的时间内解决。特别地,这个理论暗示存在着一个算法可以在大约m+n的时间内解决模式匹配问题,这里m和n分别是存储文本和模式串数组的最大索引。Knuth 和Pratt努力地重建了 Cook的证明,由此创建了这个模式匹配算法。大概是同一时间,Morris在考虑设计一个文本编辑器的实际问题的过程中创建了差不多是同样的算法。这里可以看到并不是所有的算法都是“灵光一现”中被发现的,而理论化的计算机科学确实在一些时候应用到实际的应用中。 本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/lin_bei/archive/2006/09/20/1252686.aspx
C/C++期末复习资料大汇总 一、内容概述 在本次上传中,我们为您精心整理了关于C/C++的期末复习资料。这些资料涵盖了从基础知识到进阶概念,旨在帮助您全面复习C/C++的相关内容。无论是准备期末考试还是为大作业做准备,这份资料都将为您的学习提供有力的支持。 二、资料详解 基础知识篇:针对C/C++的语法、数据类型、运算符等内容进行了详细的梳理,帮助您打好扎实的基础。 进阶概念篇:深入探讨了指针、函数、文件操作等进阶知识点,为您进一步提升编程能力提供指导。 期末复习题及答案:包含各类期末考试的经典题目及详细答案,让您熟悉考试题型,把握考试重点。 期末大作业指南:针对C/C++的期末大作业,提供了从选题到实现的全程指导,帮助您顺利完成作业。 实战案例集锦:收录了一些经典案例,让您在实践中掌握C/C++的应用技巧。 三、适用人群 这份复习资料适用于学习C/C++的各类人群,无论是初学者还是有一定编程基础的学生,都能从中获得收益。 四、使用建议 我们建议您先从基础知识开始复习,逐步深入到进阶概念。在掌握基本知识点后,结合复习题进行巩固练习,最后通过大作业和实战案例进一步提升自己的编程能力。 五、特别提示 为了更好地掌握C/C++的知识点,除了复习资料外,实际操作和练习也是非常关键的。希望这份资料能帮助您取得优异的成绩,也欢迎您在学习过程中提出宝贵的意见和建议。 最后,感谢您选择我们的复习资料,祝您学习顺利!
课程设计实现了简单C语言编译器,包括词法分析、语法分析(LL1)、语义分析、四元式优化和目标代码生成。实验内容包括表达式语法分析器、词法分析扫描器、算术表达式四元式翻译器 C语言课程设计是一个旨在帮助学生深入理解和应用C语言编程的实践项目。以下是一些关于C语言课程设计的基本步骤和建议: 明确目标和需求:首先,你需要与授课教师或课程设计的相关人员沟通,明确课程设计的需求。这包括了解课程设计的主题、目标以及需要解决的问题。这将有助于你确定设计的范围和方向。 选择项目主题:选择一个与C语言相关的项目主题。例如,你可以设计一个学生成绩管理系统、一个简单的文本编辑器或一个游戏等。确保所选主题既具有挑战性又能够展示你的C语言编程技能。 进行问题分析:一旦确定了项目主题,你需要对问题进行深入分析。这包括确定问题的输入和输出、理解问题的要求和限制条件,以及将复杂问题分解为更小的子问题。这将有助于你更好理解和解决问题。 设计算法和数据结构:针对项目需求,设计合适的算法和数据结构。这包括确定如何存储和处理数据、如何设计函数和模块等。 编写代码:使用C语言编写代码,实现项目功能。注意遵守C语言的语法规则,确保代码的可读性和可维护性。 测试和调试:在编写完代码后,进行测试和调试。确保代码能够正确运行并满足项目需求。使用调试工具和技术来查找和修复代码中的错误。 文档编写:编写项目文档,包括项目说明、功能介绍、代码注释等。这将有助于其他人理解你的项目并复用你的代码。 提交和展示:最后,将你的课程设计项目提交给教师或相关人员,并在课堂上进行展示。展示时可以介绍项目的功能、实现过程以及遇到的挑战和解决方案等。 在进行C语言课程设计时,还需要注意以下几点: 遵守编程规范,包括变量命名、代码缩进、注释等。 充分利用C语言的特点和优势,如指针、结构体、文件操作等。 注重实践和应用,通过解决实际问题来加深对C语言理解和应用能力。 在遇到困难时,及时向教师或同学请教,并查阅相关资料和文档。 通过以上步骤和建议,你可以完成一个高质量的C语言课程设计项目,并提升自己的编程能力和实践经验。
C语言课程设计的优点主要体现在以下几个方面: 基础性强:C语言是一门基础性的编程语言,它直接涉及到计算机的内存管理、指针操作等底层知识。学习C语言有助于深入理解计算机的工作原理,为后续学习其他高级语言打下坚实基础。 可移植性好:C语言编写的程序可以在多种操作系统和硬件平台上运行,因此,学习C语言可以帮助学生掌握跨平台编程的技能,提高程序的可移植性。 效率高:C语言具有高效性,它可以直接访问硬件资源,执行效率高。在编写系统级软件、嵌入式系统、游戏开发等领域,C语言具有明显优势。 结构清晰:C语言采用结构化编程思想,有助于培养学生的逻辑思维能力和程序设计能力。通过C语言的学习,学生可以掌握如何合理组织代码、设计算法和数据结构。 资源丰富:C语言拥有丰富的学习资源和社区支持,包括教材、在线课程、论坛等。学生可以通过这些资源自主学习,解决遇到的问题,提高编程能力。 实践性强:C语言课程设计通常包含大量的实践环节,如编写小程序、实现算法等。这些实践环节有助于提高学生的动手能力和解决问题的能力,使他们更好地将理论知识应用于实际项目中。 综上所述,C语言课程设计具有基础性强、可移植性好、效率高、结构清晰、资源丰富和实践性强等优点。通过C语言的学习,学生可以掌握编程的基本技能,为后续的专业学习和职业发展奠定坚实基础。
### 回答1: C 语言中的指针可以说是一个比较难理解的概念,因为它涉及到了计算机内存的操作。如果你不熟悉内存的工作原理,指针的概念可能比较抽象和难以理解。 此外,指针的概念需要对数据类型、地址、内存分配等方面有一定的了解,而这些知识对于初学者来说可能是比较困难的。 同时,指针的错误使用也很容易导致程序崩溃,因此需要十分小心。 总的来说,C 语言中的指针是一个需要深入理解和练习的概念,但是它是 C 语言编程中很重要的一部分,并且对于提高编程能力有很大的帮助。 ### 回答2: C语言指针之所以被认为难学,是因为它相对于其他编程语言来说更加底层且概念较为抽象。以下是几个可能的原因: 1. 指针内存管理:C语言中,指针内存密切相关。指针可以直接访问内存地址,但也需要手动进行内存的分配和释放,否则可能导致内存泄漏或者悬空指针等问题。 2. 指针算术:C语言允许对指针进行算术操作,如指针加减、指针递增、递减等。这要求学习者掌握指针内存地址之间的关系,并且需谨慎处理指针算术,以确保不发生内存越界等错误。 3. 多级指针C语言支持多级指针,允许指针指向指针。这增加了学习的难度,尤其是对于初学者来说,理解多级指针的概念和应用可能比较困难。 4. 字符串处理:在C语言中,字符串是以字符数组的形式存储和处理的。使用指针可以更有效地操作字符串,然而对于初学者来说,指针与字符串的关系可能需要花费更多的时间去理解和掌握。 虽然C语言指针难度较高,但掌握好指针的概念和使用方法对于理解底层编程、内存管理以及某些高级语言的底层原理都具有重要意义。通过坚持学习、阅读指针相关的资料和教程,并进行实践,可以逐渐掌握好C语言指针。 ### 回答3: C语言中的指针是许多初学者感到困惑的一个概念,因为它与其他高级语言的概念不同且较为抽象。以下是指针难以学习的几个原因: 第一,指针是一种直接访问内存地址的方式。这意味着我们需要理解计算机内存的工作原理,并学如何在程序中正确地使用这些内存地址。这对于没有计算机底层知识的人来说可能很复杂。 第二,指针有许多复杂的语法规则。例如,我们需要使用星号(*)来声明指针变量,并使用地址运算符(&)来获取变量的地址。此外,我们还需要理解指针的类型匹配规则以及指针算术运算的规则。这些规则对于初学者来说可能很令人困惑。 第三,指针容易出现错误。由于指针直接访问内存地址,因此在使用指针时出现错误可能导致程序崩溃或产生未定义的行为。例如,当指针没有正确初始化或者指针指向的内存已被释放时,我们可能遇到段错误或野指针等问题。 第四,指针的概念相对抽象。指针是一种间接引用的方式,通过指针我们可以访问其他变量的值或者修改其他变量的值。这种间接性可能增加学习的难度,尤其是对于没有编程经验的人来说。 总之,C语言指针之所以难以学习,是因为它需要理解底层的内存访问机制、掌握复杂的语法规则、注意错误的出现以及理解抽象的概念。然而,一旦掌握了指针的概念和用法,它可以成为编写高效、灵活的程序的重要工具。因此,努力学习和理解指针是编程学习的关键。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值