汇聚2000万达人的兴趣社区下载即送20张免费照片冲印
扫码下载App
温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
认认真真做事,踏踏实实做人
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
阅读(393)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_',
blogTitle:'php如何知道一个未知长度的字符串哪个字符出现的次数最多',
blogAbstract:'$str=”asdfgfdas323344##$\\$fdsdfg*$**$*$**$$fas”;//任意长度字符串//解法一(最快速的解法，但是基本功要扎实)$arr=str_split($str);$arr=array_count_values($arr);arsort($arr);print_r($arr);//解法二(朋友提供的解法，对逻辑能力有一定要求)',
blogTag:'php,位置字符串,字符出现次数,出现次数最多',
blogUrl:'blog/static/3',
isPublished:1,
istop:false,
modifyTime:0,
publishTime:3,
permalink:'blog/static/3',
commentCount:0,
mainCommentCount:0,
recommendCount:0,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:true,
hostIntro:'认认真真做事,踏踏实实做人',
hmcon:'1',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}怎么比较两个字符串大小? 要求按顺序单个比较每个字符，两个未知长度字符串从键盘输入。_百度知道
怎么比较两个字符串大小? 要求按顺序单个比较每个字符，两个未知长度字符串从键盘输入。
开始如何存放未知长度的字符串呀？这个空间应该如何分配合适呢
提问者采纳
预先定义一个很长得字符串数组。当然如果是在MFC中作那么方法更多了，然后往里面放数据。对于比较只需要得到两个字符串的长度，把编辑框定义成字符串类型变量直接往编辑框里面输入字符就好了.就是自己输入一个数字：1，做法和楼上一前半部分相似，根据数字进行申请，输入的字符串将自动赋值给字符串变量,，比较简单的方法就是拉两个编辑框，2定义未知长度的字符串有几种方式，一个一个字符进行比较就可以了
其他类似问题
键盘输入的相关知识
其他4条回答
用fuc(char*str1,char*str2)就可以了
///////////////疑问追问
满意采纳//////////////////////////////////依次对比每位的ascii码malloc 动态内存分配 例子#include&stdio.h&#include&stdlib.h&int main(){
int number = 0;
printf(&please enter the number of the array:&);
scanf(&%d&,&number);
int * array = (int *)malloc(number);
for(int i = 0; i & i ++)
printf(&please enter the %dth element:&,i+1);
scanf(&%d&,&array[i]);
for(int i = 0; i & i ++)
printf(&%d\n&,array[i]);
return 0;}
我知道这个函数，就是具体怎么使用还不懂，大侠这个程序貌似不能比较呢，帮我在休息改一下吧！
我给的这个程序是 动态数组的 没说是 比较字符串的啊比较字符串直接有函数 strcmp
可以直接用里面就是我说的 ascii码一位一位对比实现的非要自己写么
定义*p[2]，第一个输入的字符串让*p[1]指向它，第二个*p[2]指向，在逐一比较
不知道你说的是不是这个意思：string str1 = Console.ReadLine();
string str2 = Console.ReadLine();
int length = str1.Length & str2.Length ? str1.Length : str2.L
for (int i = 0; i & i++)
if (str1[i] == str2[i])
Console.Write(str1[i]);
Console.ReadKey();
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁为什么operator&&(istream&, string&)能够安全地读入长度未知的字符串？ - 推酷
为什么operator&&(istream&, string&)能够安全地读入长度未知的字符串？
一般而言，实现“读入用户输入的字符串”，程序中自然不能对用户输入的长度有所限定。这在C++中很容易实现，而在C中确没那么容易。
这一疑问，我在刚学C++的时候也在脑中闪现过；不过很快将它抛在脑后了。直到最近，我在百度知道上讨论一个单词统计问题（
）时，才重新想起。于是，翻出gcc 4.6.1的代码，浏览了一番。
首先，明确这里探讨的场景——从标准输入（或字符模式打开的文件）中读取一个字符串（换行、空格、tab间隔均可）。用C++实现这一功能有两种选择——使用C标准库和使用C++标准库，典型代码如下（错误处理代码省略）：
char word[16];
scanf(”%s”, word);
文件输入（字符模式）
char word[16];
FILE* fptr = NULL;
fptr = fopen(”input.txt”, ”rt”);
fscanf(fptr, ”%s”, word);
ifstream ifs(”input.txt”); // 默认ifsteam::in，可以不写
（由于标准输入输出和字符模式打开的文件并无太大区别，所以下面C风格只对fscanf探讨。C++ 标准输入和文件输入原本调用的就是同一个函数。）
下面，对分别对C风格的字符串输入和C++风格的字符串输入进行探讨。
scanf读入字符串
在使用fscanf(fptr, “%s”, word);方式读入字符串时，格式串”%s”上可以加长度限定，但不是必须的。
格式串上没有长度限定时
通常，我们不会在格式串上加长度限定。但是这种写法是不安全的，比如有下面的一段程序：
#include &stdio.h&
#include &string.h&
void login()
int valid = 0;
char password[6] = {0};
printf(&Please input password: &);
scanf(&%s&, password);
if( strcmp(&pass&, password) == 0 )
valid = 1;
if( valid ) {
printf(&password correct!\n&);
printf(&PASSWORD INCORRECT!\n&);
int main()
while(1) {
这段程序模拟典型的密码验证过程。可以看看程序几次的运行结果：
当用户输入的字符串长度小于等于6时，不会有问题。但如果长度大于6，可能会出现：1) password不正确已然能够验证成功（刚超出6）；或者出现 2)程序崩溃（更长）。
为什么这么做不安全？
1）栈向下生长，所以valid，和password在login()栈帧上相邻；且password的地址更低。如下所示：
如果scanf(“%s”, password);读入的字符串是”123456A”，内存映像如下：
valid所在内存被scanf读入password时越界写入，若此时输出password，valid应分别为”123456A”， 65（’A’的ASCII值，Intel机器，小端对齐）
2）实际输入的越长，读入password时越界写入的字节数就越多。
而在多数体系结构（比如Intel机器）上，函数调用时（执行call指令）会将当前的指令指针（IA32的EIP）压栈，函数返回时（执行ret指令）会将指令指针弹出；再继续运行。一旦password越界写到该位置，函数执行ret语句后EIP将指向与调用该函数前不同的地址。通常，这个地址是个无效的值，会导致段错误。如果，你向这里写入了一个可执行的函数地址（可以是操作系统API、库函数等），顺带写入了这个函数所需的参数；这样该函数返回时就会执行另外的代码，这就是著名的“缓冲区溢出攻击”。
格式串上有长度限定时
我们习惯于在printf的格式串上加长度限定，比如printf(”%5d\n”, icount);
而scanf的格式串也是可以加长度限定的，比如scanf(”%5s”,buf);
这时又会怎样呢？可经如下代码实验之：
#include &stdio.h&
int main(int argc, char *argv[])
char buf[6];
while( scanf(&%5s&, buf) == 1 ) {
printf(&scaned:%s\n&, buf);
运行如下：
（第一行为输入，后面连续几行为输出）
这样的写法是安全的，但并不是我们所需——读取未知长度的字符串。
比如在图片所示的测试中，用户输入的字符串是: 3和123456。而程序每次只能读取5个字符（结束符占一个，所以比缓冲小一个），它会将3截断。单从其返回后的状态并不能区分：这些截断原本是一个长的字符串，还是用户分别输入的多个独立的字符串，也就是：
另外，这种写法存在一个隐患，即必须时刻保证：（格式串上限定的长度）≤ （实际输入缓冲长度 － 1）。实际编程时，要一直保证这一关系比较困难。尤其是缓冲的大小和格式串长度不在一个代码片段中时；这同时也给修改代码带来了不小的麻烦。
下面，来看看C++标准库是如何实现的。
operator&&()读入字符串
使用C++标准库，实现读入一个（长度未知的）字符串的代码非常简单，只需声明一个std::，然后cin&&即可：
#include &iostream&
#include &string&
这和，输入一个int，float的代码没什么两样——对程序员和用户都很友好。
对于cin &&可以读入任意长度的字符串（只要内存够用），就和std::string的operator+=一样，大家都司空见惯了（我也是）。直到最近，当我从会C的角度来看这个问题时，便有了标题的疑问。
（同时发现Eclipse(CDT)对运算符重载代码也能很方便的定位，只需按住Ctrl，鼠标点击你要查看的运算符即可，该opertor的定义立刻出现）
Eclipse直接定位到的是：
template&&
basic_istream&char&&
operator&&(basic_istream&char&& __is, basic_string&char&& __str);
而，该段特化版本的声明在我的gcc 4.6.1中并不能继续定位到实现。而紧邻它的泛型版的声明：
&basic_string.h&：
Read stream into a string.
Input stream.
@param str
Buffer to store into.
Reference to the input stream.
Stores characters from @a is into @a str until whitespace is found, the
end of the stream is encountered, or str.max_size() is reached.
is.width() is non-zero, that is the limit on the number of characters
stored into @a str.
Any previous contents of @a str are erased.
template&typename _CharT, typename _Traits, typename _Alloc&
basic_istream&_CharT, _Traits&&
operator&&(basic_istream&_CharT, _Traits&& __is,
basic_string&_CharT, _Traits, _Alloc&& __str);
template&&
basic_istream&char&&
operator&&(basic_istream&char&& __is, basic_string&char&& __str);
可以找到实现：
&basic_string.tcc&:
// 21.3.7.9 basic_string::getline and operators
basic_istream
operator&&
basic_istream
&&& &&&&&&
basic_string
basic_istream
__istream_type
basic_string
__string_type
__istream_type
__ios_base
__istream_type
__int_type
__string_type
__size_type
&&&&&&&&&&&&&&
__ctype_type
__ctype_type
ctype_base
__ctype_base
__size_type
__extracted = 0;
__ios_base
__ios_base
__istream_type
&&& & __try
// Avoid reallocation for common case.
&&& &&&&& __str.erase();
__buf[128];
__size_type
__len = 0; &&&&&
streamsize
__size_type
__n = __w & 0 ?
static_cast
__size_type
&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&& : __str.max_size();
__ctype_type
& __ct = use_facet&
__ctype_type
.getloc());
__int_type
__int_type
.rdbuf()-&sgetc();
(__extracted & __n
&&&&&&& &&&& && !
::eq_int_type(__c, __eof)
&&&&&&& &&&& && !__ct.is(
__ctype_base
&&&&&&&&&&&&&&& &
::to_char_type(__c)))
&&&&&&& &&& {
&&&&&&& &&&&& __str.append(__buf,
&&&&&&& &&&&& __len = 0;
&&&&&&& &&& }
&&&&&&& & __buf[__len++] =
::to_char_type(__c);
&&&&&&& & ++__
&&&&&&& & __c =
.rdbuf()-&snextc();
&&& &&&&& __str.append(__buf, __len);
::eq_int_type(__c, __eof))
&&&&&&& __err |=
__ios_base
.width(0);
&&& & __catch(__cxxabiv1::
__forced_unwind
._M_setstate(
__ios_base
::badbit);
&&& &&&&& __throw_exception_
&&& & __catch(...)
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator&& and getline() for string&&
// might cause endless loop
._M_setstate(
__ios_base
::badbit);
// 211.& operator&&(istream&, string&) doesn't set failbit
(!__extracted)
&&& __err |=
__ios_base
.setstate(__err);
暂且不看错误处理，从Ln1017到Ln1045即为主要逻辑。看到1018行的__buf[]数组，我们已经能够猜出大概。
这里调用了basic_istream的一些成员函数：
&&& width() &用于控制输入输出的宽度，相当于printf，scnaf格式串上的长度限定的作用。它有两个版本，这里都调用了。
& & & & & & 无参数版本返回当前字段的宽度，默认情况下返回0；有参数版本用于设定当前字段宽度，这里设定为了0。
&&& rdbuf() &返回和basic_istream相关的basic_streambuf（存放实际字符）
和streambuf的一些成员函数：
&&& sgetc() &读取当前字符
& & snextc() &前进到下一位置，并读取字符
以及string的成员函数:
&&& append() &字符串追加
此时，再看Ln1025—Ln1041就非常清楚了：
__int_type __c = __in.rdbuf()-&sgetc();
while (__extracted & __n
&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(__ctype_base::space,
_Traits::to_char_type(__c)))
if (__len == sizeof(__buf) / sizeof(_CharT))
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
__buf[__len++] = _Traits::to_char_type(__c);
__c = __in.rdbuf()-&snextc();
__str.append(__buf, __len);
迁移到C环境
据此我们可以写出一个C语言版本的fgetvs()：
// get variable length string.
char *fgetvs(FILE *stream)
char buf[4] = {0};
size_t len = 0;
char *str = NULL;
size_t slen = 0;
c = fgetc(stream);
while( c != EOF && !isspace(c) )
if(len == sizeof(buf)/sizeof(char))
void *old =
str = strapp(str, slen, buf, sizeof(buf)/sizeof(char));
free(old);
buf[len++] = (char)c;
c = fgetc(stream);
// printf(&DEBUG: %c, %d, %s\n&, c, len, buf);
str = strapp(str, slen, buf, len);
// slen +=
（这段代码的变量命名基本上与上面operator&&里的一致，但没有__下划线）
这段代码使用（char*,size_t）模拟std::string，可以避免频繁调用strlen。（也可以仅用char*，每次strlen求长度）
strapp返回新字符串而不改变传入的两个字符串。
代码的难点由转移到了strapp()，正确的写出strapp也不难，完整的模拟程序代码如下：
#include &stdio.h&
#include &stdlib.h& // for malloc free
#include &assert.h& // for assert
#include &ctype.h&
// for isspace
#include &string.h& // for memcpy
// string append.
static char *strapp(const char *str, size_t len,
const char *appstr, size_t applen)
char *pnew = NULL;
pnew = (char*)malloc( (len + applen + 1) * sizeof(char));
assert(pnew != NULL);
memcpy(pnew, str, len);
memcpy(pnew+len, appstr, applen);
pnew[len+applen] = '\0';
// get variable length string.
char *fgetvs(FILE *stream)
char buf[4] = {0};
size_t len = 0;
char *str = NULL;
size_t slen = 0;
c = fgetc(stream);
while( c != EOF && !isspace(c) )
if(len == sizeof(buf)/sizeof(char))
void *old =
str = strapp(str, slen, buf, sizeof(buf)/sizeof(char));
free(old);
buf[len++] = (char)c;
c = fgetc(stream);
// printf(&DEBUG: %c, %d, %s\n&, c, len, buf);
str = strapp(str, slen, buf, len);
// slen +=
int main(int argc, char *argv[])
puts(fgetvs(stdin));
getline也一样
与读取一个字符串相似的问题是——读取一行（换行符间隔），二者并无太大区别，读取字符串以空白字符（空格、TAB、换行）间隔，读取一行则只以换行间隔。
只需将上面fgetvs()代码while条件上的:
!isspace(c)
c != ‘\n’
即可实现fgetvl()：
// get variable length line.
char *fgetvl(FILE *stream)
char buf[4] = {0};
size_t len = 0;
char *str = NULL;
size_t slen = 0;
c = fgetc(stream);
while( c != EOF && c != '\n' )
if(len == sizeof(buf)/sizeof(char))
void *old =
str = strapp(str, slen, buf, sizeof(buf)/sizeof(char));
free(old);
buf[len++] = (char)c;
c = fgetc(stream);
// printf(&DEBUG: %c, %d, %s\n&, c, len, buf);
str = strapp(str, slen, buf, len);
// slen +=
为什么（未知长度的）字符串空间不能放在栈上？
上面对于scanf格式串上没有长度限定的安全性的解释已经同时回答了这个问题。C++的std::string对象本身只存放字符指针（以及缓冲长度），实际内存在堆上开辟（new/malloc申请）。我们用C模拟的版本可以很清楚的看到malloc。究其根本，其一，因为栈向低地址方向生长，而字符串通常向高地址方向写入。其二，只有函数调用栈顶的函数的栈帧可变，而该函数一旦返回，该函数栈帧上的所有内存都会被回收；在不借助堆的情况下，即便实现了在getvs栈上开辟空间，字符串向低地址方向写入；那么返回时这段空间还是会被撤销，要想保存getvs读入的字符串，必须在getvs调用前（上一栈帧）也在栈上开辟同样大小的空间；而这与“只有调用栈顶的函数的栈帧可变”向矛盾。因此，不能将变长字符串存放在栈空间上。
这一场景下体现出C++标准库的哪些好处？
个人感到的好处是string::append()。std::string实现了Buffer的功能——提供了append,insert等方法，而不需用户关心内存操作。
另一个人感到的好处是由于operator&&被重载带来的“接口一致性”，cin&&str和cin&&icount用起来差不多。
已发表评论数()
&&登&&&陆&&
已收藏到推刊！
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见有n个长为m+1的字符串，如果某个字符串的最后m个字符与某个字符串的前m个字符匹配，则两个字符串可以联接 - martin_liang的专栏
- 博客频道 - CSDN.NET
转自：&/tractorman/p/4065544.html
算法中的三重循环
第三重的意思是
假设现在要求 &1, 3 &两个节点可拼接的最大距离
先看 ： &1:0 & &1:1 & 1:2 & 1:3 & 1:4 &
& & & & & & & 0:3 & 1:3 & &2:3 & 3:3 & 4:3
竖着匹配， 如果 1和0之间可以拼接，3和0之间可以拼接，就可以算出1和三之间通过0进行拼接的拼接距离， 如此类推，比较这5对，可以计算出1和3两个节点最大的拼接距离
题目要求：
　　有n个长为m+1的字符串，如果某个字符串的最后m个字符与某个字符串的前m个字符匹配，则两个字符串可以联接。
　　问这n个字符串最多可以连成一个多长的字符串，如果出现死循环，则返回错误。
题目分析：
　　1.每个字符串都是长为m+1的字符串，两个字符串匹配后长度应该为1+m+1=m+2;
　 2.用图的思想来解。如果某两个顶点匹配，则在图中的该两点连线，当遍历完所有点之后，判断该图是否有环，没有就求该图的最长路径；
　 3.求图的最长路径与求最短路径类似，可以参考Floyd最短路径算法；
代码实现：
代码链接：http://blog.csdn.net/cxh/article/details/6637006
#include&iostream&
#include&string&
using namespace
#define length 14
bool Isconnect(string str1,string str2)
if(str1.size()!=str2.size())
return false;
int m=str1.size();
for(int i=0;i&m-1;i++)
if(str1[i+1]!=str2[i])
return false;
return true;
void Maxstring(string str[])
int G[length][length]={0};
for(int i=0;i&i++)
for(int j=0;j&j++)
if(Isconnect(str[i],str[j]))
G[i][j]=1;
for(int i=0;i&i++)
for(int j=0;j&j++)
for(int k=0;k&k++)
if(G[i][k]!=0&&G[k][j]!=0)
int dis=G[i][k]+G[k][j];
if(dis&G[i][j])
for(int i=0;i&i++)
if(G[i][i]&1)
cout&&&circle is deteted&&&
int max=0;
for(int i=0;i&i++)
for(int j=0;j&j++)
if(G[i][j]&max)
max=G[i][j];
cout&&&Max length is &&&max+str[0].size()&&
int main()
string str[length]={
&babc&};//用这个替换下面一行，就会形成环
Maxstring(str);
很多时候不是我们做不好，而是没有竭尽全力......
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：147157次
积分：4129
积分：4129
排名：第3088名
原创：237篇
转载：272篇
评论：11条
(20)(13)(12)(27)(61)(35)(19)(23)(18)(20)(22)(4)(6)(4)(9)(2)(6)(5)(1)(11)(58)(29)(22)(6)(8)(10)(9)(3)(13)(3)(10)(9)(12)不用strcat函数连接两个字符串
[问题点数：100分，结帖人qq_]
不用strcat函数连接两个字符串
[问题点数：100分，结帖人qq_]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
相关帖子推荐：
2013年 总版技术专家分年内排行榜第三
2012年 总版技术专家分年内排行榜第七
匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。}