字符串

那你要计算你画的字符串的长度和宽度，且需根据字体、型号大小、字体样式（居中还是靠左）。这些来完成。且还要注意有无换行符号 和 。以下是GDI代码，供你参考。void CalculateTextSize() { if ( m_bAutoCalText && ::IsWindow(m_hWnd) ) { // Calculate text size. CClientDC dc(m_hWnd); dc.SelectFont(m_Font); dc.SetTextAlign(m_uTextStyle); CSize szText; CString strText =_T(""); int nHeight = 0; int nWidth = 0; // Get max text length and width. for (int i = 0; i < m_strText.GetLength(); i++) { strText += m_strText[i]; if (m_strText[i] == " " ||m_strText[i] == " ") { dc.GetTextExtent(strText,strText.GetLength(), &szText); nHeight += szText.cy; nWidth = nWidth > szText.cx ? nWidth :szText.cx; strText = _T(""); } } if (strText.GetLength() > 0) { dc.GetTextExtent(strText,strText.GetLength(), &szText); nHeight += szText.cy; nWidth = nWidth > szText.cx ?nWidth : szText.cx; strText = _T(""); } ResizeClient(nWidth, nHeight); } Invalidate(); }

相关代码如下： /// <summary> /// 绘制文本自动换行（超出截断） /// </summary> /// <param name="graphic">绘图图面</param> /// <param name="font">字体</param> /// <param name="text">文本</param> /// <param name="recangle">绘制范围</param> private void DrawStringWrap(Graphics graphic, Font font, string text, Rectangle recangle) { List<string> textRows = GetStringRows(graphic, font, text, recangle.Width); int rowHeight = (int)(Math.Ceiling(graphic.MeasureString("测试", font).Height)); int maxRowCount = recangle.Height / rowHeight; int drawRowCount = (maxRowCount < textRows.Count) ? maxRowCount : textRows.Count; int top = (recangle.Height - rowHeight * drawRowCount) / 2; StringFormat sf = new StringFormat(); sf.Alignment = StringAlignment.Near; sf.LineAlignment = StringAlignment.Center; for (int i = 0; i < drawRowCount; i++) { Rectangle fontRectanle = new Rectangle(recangle.Left, top + rowHeight * i, recangle.Width, rowHeight); graphic.DrawString(textRows, font, new SolidBrush(Color.Black), fontRectanle, sf); } } /// <summary> /// 将文本分行 /// </summary> /// <param name="graphic">绘图图面</param> /// <param name="font">字体</param> /// <param name="text">文本</param> /// <param name="width">行宽</param> /// <returns></returns> private List<string> GetStringRows(Graphics graphic, Font font, string text, int width) { int RowBeginIndex = 0; int rowEndIndex = 0; int textLength = text.Length; List<string> textRows = new List<string>(); for (int index = 0; index < textLength; index++) { rowEndIndex = index; if (index == textLength - 1) { textRows.Add(text.Substring(RowBeginIndex)); } else if (rowEndIndex + 1 < text.Length && text.Substring(rowEndIndex, 2) == "\r\n") { textRows.Add(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex)); rowEndIndex=index += 2; RowBeginIndex = rowEndIndex; } else if (graphic.MeasureString(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex + 1), font).Width > width) { textRows.Add(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex)); RowBeginIndex = rowEndIndex; } } return textRows; }

相关代码如下： /// <summary> /// 绘制文本自动换行（超出截断） /// </summary> /// <param name="graphic">绘图图面</param> /// <param name="font">字体</param> /// <param name="text">文本</param> /// <param name="recangle">绘制范围</param> private void DrawStringWrap(Graphics graphic, Font font, string text, Rectangle recangle) { List<string> textRows = GetStringRows(graphic, font, text, recangle.Width); int rowHeight = (int)(Math.Ceiling(graphic.MeasureString("测试", font).Height)); int maxRowCount = recangle.Height / rowHeight; int drawRowCount = (maxRowCount < textRows.Count) ? maxRowCount : textRows.Count; int top = (recangle.Height - rowHeight * drawRowCount) / 2; StringFormat sf = new StringFormat(); sf.Alignment = StringAlignment.Near; sf.LineAlignment = StringAlignment.Center; for (int i = 0; i < drawRowCount; i++) { Rectangle fontRectanle = new Rectangle(recangle.Left, top + rowHeight * i, recangle.Width, rowHeight); graphic.DrawString(textRows, font, new SolidBrush(Color.Black), fontRectanle, sf); } } /// <summary> /// 将文本分行 /// </summary> /// <param name="graphic">绘图图面</param> /// <param name="font">字体</param> /// <param name="text">文本</param> /// <param name="width">行宽</param> /// <returns></returns> private List<string> GetStringRows(Graphics graphic, Font font, string text, int width) { int RowBeginIndex = 0; int rowEndIndex = 0; int textLength = text.Length; List<string> textRows = new List<string>(); for (int index = 0; index < textLength; index++) { rowEndIndex = index; if (index == textLength - 1) { textRows.Add(text.Substring(RowBeginIndex)); } else if (rowEndIndex + 1 < text.Length && text.Substring(rowEndIndex, 2) == "\r\n") { textRows.Add(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex)); rowEndIndex=index += 2; RowBeginIndex = rowEndIndex; } else if (graphic.MeasureString(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex + 1), font).Width > width) { textRows.Add(text.Substring(RowBeginIndex, rowEndIndex - RowBeginIndex)); RowBeginIndex = rowEndIndex; } } return textRows; }

gf.DrawString("竖着的值", Font, Brush, new point(X,Y) ,new StringFormat(StringFormatFlags.DirectionVertical));用这个方法可以

用FOR循环显示，将显示的字设定好坐标就行了

Private Sub command1_click()Debug.Print (UTF8EncodeURI("汉字"))Debug.Print (GBKEncodeURI("汉字"))End SubFunction UTF8EncodeURI(szInput)Dim wch, uch, szRetDim xDim nAsc, nAsc2, nAsc3If szInput = "" ThenUTF8EncodeURI = szInputExit FunctionEnd IfFor x = 1 To Len(szInput)wch = Mid(szInput, x, 1)nAsc = AscW(wch)If nAsc < 0 Then nAsc = nAsc + 65536If (nAsc And &HFF80) = 0 ThenszRet = szRet & wchElseIf (nAsc And &HF000) = 0 Thenuch = "%" & Hex(((nAsc 2 ^ 6)) Or &HC0) & Hex(nAsc And &H3F Or &H80)szRet = szRet & uchElseuch = "%" & Hex((nAsc 2 ^ 12) Or &HE0) & "%" & _Hex((nAsc 2 ^ 6) And &H3F Or &H80) & "%" & _Hex(nAsc And &H3F Or &H80)szRet = szRet & uchEnd IfEnd IfNextUTF8EncodeURI = szRetEnd FunctionFunction GBKEncodeURI(szInput)Dim i As LongDim x() As ByteDim szRet As StringszRet = ""x = StrConv(szInput, vbFromUnicode)For i = LBound(x) To UBound(x)szRet = szRet & "%" & Hex(x(i))NextGBKEncodeURI = szRetEnd Function

有ascii码啊，直接就可以转换成英文

数组不是这样写的，字符串当做整体的1没错。

方法1、用URLDecode解码就可以了。String code = "D:/%e5%ad%a6%e6%b5%b7/My%20Course/%e8%ae%a1%e7%ae%97%e4%b8%8e%e8%bd%af%e4%bb%b6%e5%b7%a5%e7%a8%8b/Java%20workspace/my Project/bin/";try{ String src=URLDecoder.decode(code,"UTF-8");//注意编码和输入时一致 System.out.print(src);}catch (UnsupportedEncodingException e){ e.printStackTrace();}======显示:D:/学海/My Course/计算与软件工程/Java workspace/my Project/bin/方法2:URI有自己的getPath方法，直接返回的就是解码后的路径比如System.out.print(url.getPath());

直接使用Uri类的构造函数或者使用TypeDescriptor+TypeConverter 类自己转换

以下是我们在Api接口中的定义方法//以前我们使用我们定义好的POJO或javabean类作为callback的泛型，以便Retrofit帮我们解析@POST("/interface/xxxxxx")void getCouponList(Callback<Coupon> reponse);//但如果我们想获得JSON字符串，Callback的泛型里就不能写POJO类了，要写Response（retrofit.client包下）@POST("/interface/xxxxxx")void getCouponList(Callback<Response> reponse);那么在我们请求接口的时候，只需简单一行代码，就能拿到服务器返回的JSON字符串了ZhixueApiUtil.getInstance().getZhixueApi().getCouponList(new Callback<Response>() {@Overridepublic void success(Response response, Response response1) {//注意这里用第一个Response参数的String jsonString = new String(((TypedByteArray) response.getBody()).getBytes());//再使用Retrofit自带的JSON解析（或者别的什么）Coupon coupon = new Gson().fromJson(jsonString, Coupon.class);......}@Overridepublic void failure(RetrofitError error) {......}});

字符串就是一串字符，当然，一个字符在vb中也被认定为字符串12345这个是数字，在vb中可以用integer、double，等定义，可以进行加减操作12345+1=12346“12345”则表示字符串，不能进行加减操作str是吧数字类型转化成字符串str(12345)="12345"val是把字符串中的数字转化成数字val("12345")=12345

具体一些，是什么样的情况，字符串一般都有许多类，内置方法

<?php$a= array("a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z");$b= str_ireplace($a, "", "asdasASDDA1231SDA1213aASDASDsdas");echo $b;?>

长vvvvb顶顶顶顶顶顶顶顶顶顶顶顶顶

一 造成segment fault，产生core dump的可能原因1.内存访问越界a) 由于使用错误的下标，导致数组访问越界b) 搜索字符串时，依靠字符串结束符来判断字符串是否结束，但是字符串没有正常的使用结束符c) 使用strcpy, strcat, sprintf, strcmp, strcasecmp等字符串操作函数，将目标字符串读/写爆。应该使用strncpy, strlcpy, strncat, strlcat, snprintf, strncmp, strncasecmp等函数防止读写越界。2 多线程程序使用了线程不安全的函数。3 多线程读写的数据未加锁保护。对于会被多个线程同时访问的全局数据，应该注意加锁保护，否则很容易造成core dump4 非法指针a) 使用空指针b) 随意使用指针转换。一个指向一段内存的指针，除非确定这段内存原先就分配为某种结构或类型，或者这种结构或类型的数组，否则不要将它转换为这种结构或类型 的指针，而应该将这段内存拷贝到一个这种结构或类型中，再访问这个结构或类型。这是因为如果这段内存的开始地址不是按照这种结构或类型对齐的，那么访问它 时就很容易因为bus error而core dump.5 堆栈溢出.不要使用大的局部变量（因为局部变量都分配在栈上），这样容易造成堆栈溢出，破坏系统的栈和堆结构，导致出现莫名其妙的错误。今天调试程序时遇到了一个问题，当我用GDB调试程序时出现了Segmentation fault，以前没有遇到过，最后查看资料，有点明白了。出现了Segmentation fault，基本上的原因是，非法的内存访问。例如数组的越界，在循环操作时循环变量的控制问题，也有字符串拷贝时长度溢出，指针指向了非法的空间，还有就是申明一个指针，但却没有对其初始化，就直接引用，或者没有开辟内存空间就释放内存，所以要检查申请空间时间偶成功。。。还有那个问题在调试时会有这样的信息：Program terminated with signal SIGSEGV, Segmentation fault.对于SIGSEGV这个信号，经常会和SIGBUS信号出现在一块，SIGBUS与SIGSEGV信号的一般区别如下:1) SIGBUS(Bus error)意味着指针所对应的地址是有效地址，但总线不能正常使用该指针。通常是未对齐的数据访问所致。2) SIGSEGV(Segment fault)意味着指针所对应的地址是无效地址，没有物理内存对应该地址。通常导致段错误的几个直接原因：1、解除引用一个包含非法值的指针。2、解除引用一个空指针（常常由于从系统程序中返回空指针，并未经检查就使用）。3、在未得到正确的权限时进行访问。4、用完了堆栈或堆空间（虚拟内存虽然巨大，但绝非无限）。

楼上答得不对，请相信我的方法，已经确认过：String s="abc";String s1=URLEncoder.encode(s, "utf-8");

String msg = new String();String不能new 只要String msg;就好了。

boolean p=(sss=="true"?true:false);

取出url的字符：(?<=url=")w+(?=")取出genreld的字符：(?<=genreld=)d+(?=^) 临时写的，你试试可不可以

global type gf_split_parm from function_objectend typeforward prototypesglobal function integer gf_split_parm (string as_parm, ref string as_data[])end prototypesglobal function integer gf_split_parm (string as_parm, ref string as_data[]);//拆分返回值long ll_pos, ll_itemif isnull(as_parm) then as_parm = ""end ifif len(as_parm) <= 0 then return 0end ifll_item = 0ll_pos = pos(as_parm, ",")do while ll_pos > 0 ll_item ++ as_data[ll_item] = left(as_parm, ll_pos - 1) as_parm = mid(as_parm, ll_pos + 1) ll_pos = pos(as_parm, ",")loopll_item ++as_data[ll_item] = as_parmreturn ll_itemend function

你就让他逐个读一边.然后想截取多少都行.

方法一可以使用库函数#include<stdio.h>strcpy(char *target, const char *source)方法二可以自定义函数复制int strncpy(char *target, int max, const char *source){int i;for(i = 0; i < max-1 && source[i]; i++)target[i] = source[i];target[i] = "";return 1;}

C语言中想把一个数据分块，可以在读取数据的时候进行分块储存，不要整体读入之后，再进行分块。如果数据是其他方式导入的，那只能通过先储存到硬盘，再读到内存，通过文件指针的移动，依次分块读入。因为，数据存储是用整块内存存储的，不能直接将内存（即数据）进行分块，memcpy也只能获取数据前边一部分。

给你一个半吊子程序吧，对你有帮助就行了，做完就没意思了，^_^#include#include#includeclassMyString{public:MyString():m_pData(NULL),m_iLen(0){}~MyString(){if(m_pData){deletem_pData;}}char*GetStr()const{returnm_pData;}MyString&operator=(char*str){intiLen=strlen(str);m_pData=newchar[iLen+1];strncpy(m_pData,str,iLen);m_pData[iLen]="";m_iLen=iLen;return*this;}booloperator<(constMyString&other){returnstrcmp(m_pData,other.GetStr())<0?true:false;}booloperator>(constMyString&other){returnstrcmp(m_pData,other.GetStr())>0?true:false;}intGetLength()const{returnm_iLen;}MyString&Concat(constMyString&other){m_iLen+=other.GetLength();char*newData=newchar[m_iLen+1];sprintf(newData,"%s%s",m_pData,other.GetStr());newData[m_iLen]="";deletem_pData;m_pData=newData;return*this;}private:char*m_pData;intm_iLen;};intmain(){MyStringmystring1;MyStringmystring2;mystring1="33";mystring2="44";//比较if(mystring1>mystring2){cout<<"mystring1>mystring2"<mystring2)"<评论00加载更多

Jimmy1224 码龄11年关注 字符串是一种重要的数据类型，但是C语言并没有显式的字符串数据类型，因为字符串以字符串常量的形式出现或者存储于字符数组中。字符串常量适用于那些程序不会对它们进行修改的字符串。所有其他字符串都必须存储于字符数组或动态分配的内存中。本文描述处理字符串和字符的库函数，以及一些相关的，具有类似能力的，既可以处理字符串也可以处理非字符串数据的函数。1.1 字符串基础 字符串是一串零个或多个字符，并且以一个位模式全0的NUL字节("")结尾。NUL字节是字符串的终止符，但它本身并不是字符串的一部分，所以字符串长度并不包括NUL字节。头文件string.h包含了字符串函数所需的圆形和声明。在程序中包含这个头文件确实是个好主意，因为有了它所包含的原型，编译器可以更好地为程序执行错误检查。1.2字符串长度 字符串的长度是它所包含的字符个数，不包含NUL字节。我们很容易对字符进行计数来计算字符串的长度。需要说明的是，如果strlen函数的参数不是一个以NUL字节结尾的字符序列，它将继续进行查找，直到发现一个NUL字节为止，这样strlen函数的返回值将是不确定数！ 库函数strlen的源码如下：size_t strlen(char const * string){ int length; for (length = 0; *string++ != ""; ;) { length += 1; } return length;}注意： strlen返回一个类型为size_t的值，它是一个无符号整数类型。在表达式中使用无符号可能导致不可预料的结果。例如：if ( strlen(x) >= strlen(y) ){...} if (strlen(x) - strlen(y) >= 0){...} 上面两个表达式看似相等，但事实上它们是不想等的。第一条语句是我们所预想的那样工作，但第2条语句的结果永远为真。因为strlen的结果是无符号，所以strlen(x)-strlen(y)的结果也是个无符号数，而无符号数都是大于等于“0”的。在表达式中如果同时包含了无符号和有符号数同样会产生奇怪的结果。1.3 不受限制的字符串函数 最常用的字符串函数都是“不受限制”的，就是说它们只是通过寻找字符串参数结尾的NUL字节来判断它们的长度。这些函数一般都指定一块内存用于存放结果字符串。在使用这些函数时，程序员必须保证结果字符串不会溢出这块内存。1.3.1 复制字符串 用于复制字符串的函数是strcpy，它的原型如下：char *strcpy( char *dst, char const *src);这个函数把参数src字符串复制到dst参数。如果参数src和dst在内存中出现重叠，其结果是未定义的。由于dst参数将进行修改，所以它必须是个字符数组或者是一个指向动态分配内存的数组指针，不能使用字符串常量。 目标参数以前的内容将被覆盖丢失。即使新的字符串比dst原先的内存更短，由于新的字符串是以NUL字节结尾，所以老字符串最后剩余的几个字符也会被有效地删除。需要注意的是字符结束标志也将被复制。例如：char message[] = "message";...if (...){ strcpy( message, "Dif");}如果条件为真并且复制顺利执行，数组将包含下面的内容：第一个NUL字节后面的几个字符再也无法被字符串函数访问，因此从任何角度实现看，它们都已经是丢失的了。注意： 程序员必须保证目标字符数组的空间足以容纳需要复制的字符串。如果字符串比数组长，多余的字符仍被复制，它们将覆盖原先存储于数组后面的内存空间的值。strcpy无法解决这个问题，因为它无法判断目标字符数组的长度。1.3.2 连接字符串 strcat函数可以实现一个字符串添加到另一个字符串的后面。函数原型如下：char *strcat( char *dst, char const *src); strcat函数要求dst参数原先已经包含一个字符串(可以是空字符串)。它找到这个字符串的末尾，并把src字符串的一份拷贝添加到这个位置。如果src和dst的位置发生重叠，其结果是未定义的。 下面是这个函数的常见用法：strcpy( message, "hello");strcpy( message, customer_name);注意：程序员必须保证目标字符数组剩余的空间足以保存整个src源字符串。1.3.3 字符串比较 库函数strcmp的原型如下：int strcmp( char const *s1, char const *s2);字符串比较的规则：对两个字符串自左向右逐个字符比较(按ASCII码值大小比较)，直到出现不同的字符或遇到‘"为止，如果全部相同则认为相等。1. s1小于s2，函数返回负整数；2. s1大于s2，函数返回正整数；3. s1等于s2，函数返回0；注意：比较两个字符串更好的方法是把返回值与零进行比较。if ( 0 == strcmp(str1,str2)){ ...}注意： 由于strcmp并不修改它的任一个参数，所以不存在溢出字符数组的危险。strcmp函数的字符串参数也必须以一个NUL字节结尾。如果不是，strcmp就可能对参数后面的字节进行比较，这个比较结果无意义！1.4 长度受限的字符串函数 标准库函数还包含了一些函数，这些函数接受一个显式的长度参数，用于限定进行复制或比较的字符数。这些函数提供了一种方便的机制，可以防止难以预料的长字符串从它们的目标数组溢出。 这些函数的原型如下所示，和不受限制版本一样，如果源参数和目标参数发生重叠，strncpy和strncat的结果都是未定义。char *strncpy(char *dst, char const *src, size_t len );char *strncat(char *dst, char const *src, size_t len );char *strncmp(char const *s1, char const *s2, size_t len );1.4.1 strncpy 和strcpy一样，strncpy把源字符串的字符复制到目标数组。但它总是向dsr写入len个字符。如果strlen(src)的值小于len，dst数组就用额外的NUL字节填充到len长度。如果strlen(src)的值大于或等于len，那么只有len个字符被复制到dst中。此时，它的结果将可能不会以NUL字节结尾。例如：char dst[10];char src[] = "abcdefghijklmn"; strncpy(dst, src,5);//dst字符数组不是以NUL结尾，len是23，是个随机数int len = strlen(dst);警告： strncpy调用的结果可能不是一个字符串，因此字符串必须是以NUL字节结尾。如果在一个需要字符串的地方(例如:strlen函数参数)使用了没有以NUL字节结尾的字符序列，会发生什么情况呢？strlen函数不知道NUL字节是没有的，所以它将继续一个字符一个字符的查找，知道发现NUL字节为止。或者如果函数试图访问系统分配给这个程序以外的内存范围，程序就会崩溃。 这个问题只有当你使用strncpy函数创建字符串，然后或者对它们使用str开头的库函数，或者在printf中使用%s格式打印它们时才会发生。考虑如下代码：char buffer[BSIZE];...strncpy(buffer,name,BSIZE);buffer[BSIZE-1] = ""; 如果strlen(name)小于BSIZE，之后的赋值语句不起作用。但是，name长度很长，这条赋值语句可以保证buffer中的字符串是以NUL字节结尾。以后对这个数组使用strlen等其它函数就会正常工作。1.4.2 strncat strncat也是一个长度受限的函数，但它和strncpy不同，strncat从src中最多复制len个字符到目标数组的后面。并且，strncat总是在结果字符串后面添加一个NUL字节。它不管目标参数除去原先存在的字符串之后留下的空间够不够。1.4.3 strncmp strncmp用于比较两个字符串，但它最多比较len个字节。如果两个字符串在第len个字符之前存在不等的字符，这个函数停止比较，返回结果。如果两个字符串的前len个字符相等，函数就返回零。1.5 字符串查找基础 标准库中存在许多函数，它们用各种不同的方法查找字符串。1.5.1 查找一个字符 在一个字符串中查找一个特定字符最容易的方法是使用strchr和strchr函数，它们的原型如下：char *strchr( char const *str, int ch);char *strrchr( char const *str, int ch); 它们的第二个参数是一个整型值。但是，它包含了一个字符值(ASCII)。strchr在字符串中str查找字符ch第1次出现的位置，找到后函数返回一个指向该位置的指针。如果该字符并不存在于字符串中，函数就返回一个NUL指针。 strrchr的功能与strchr基本一致，只是它所返回的是一个指向字符串中该字符最后一次出现的位置(r:最右边)。例如：char src[] = "abc12def12";printf("the first = %s ",strchr(src,49));//strchr(src,"1")1.5.2 查找任何几个字符 strprk是个更为常见的函数，它是查找任何一组字符第一次在字符串中出现的位置，它的原型如下：char *strpbrk( char const *str, char const *group);这个函数返回一个指向str中第1个匹配group中任何一个字符的字符位置。如果未找到函数返回一个NULL指针。例如： char src[] = "123qaz!@#"; char group[] = "aq!"; printf("location = %s ",strpbrk(src,group));//qaz!@#，group中的字符第1次出现的位置是q1.5.3 查找一个子串 为了在字符串中查找一个子串，我们可以使用strstr函数，它的原型如下：char *strstr( char const *s1, char const *s2 ); 这个函数在s1中查找整个s2第1次出现的位置，并返回一个指向该位置的指针。如果s2没有完整的出现在s1中任何地方，函数返回NULL指针。如果s2是一个空字符串，函数就返回s2。1.6 高级字符串查找1.6.1 查找一个字符串前缀 strspn和strcspn函数用于在字符串的起始位置对字符计数。它们的函数原型如下：size_t strspn( char const *str, char const *group );size_t strcspn( char const *str, char const *group );1.6.2 查找标记 一个字符串常常包含几个单独的部分，它们彼此分隔开来。每次为了处理这些部分，你首先必须把它们从字符串中抽取出来。这个任务正是strtok函数所实现的功能。它从字符串中隔离各个单独的称为标记(token)的部分，并丢弃分割符。它的原型如下：char *strtok( char *str, char const *sep);sep参数是个字符串，定义了用作分隔符的字符集。str指定一个字符串，它包含零个或多个有sep字符串中一个或多个分隔符分隔的标记。strtok找到str的下一个标记，并将其用NUL结尾，然后返回一个指向这个标记的指针。高级字符串查找将另外详解描述！1.7 字符操作 标准库包含了两组函数，用于操作单独的字符，它们的原型位于头文件ctype.h。第一组函数用于字符分类，第二组函数用于转换字符。1.7.1 字符分类 每个分类函数接受一个包含字符值的整型参数。函数测试这个字符并返回一个整型值，表示真或假。int isalnum( int ch ); int iscntrl( int ch ); int islower( int ch ); int isprint( int ch ); int isupper( int ch ); int isspace( int ch );1.7.2 字符转换 转换函数把大写字母转换为小写字母或把小写字母转换为大写字母。它们的函数原型如下： int tolower( int ch ); int toupper( int ch ); toupper函数返回其参数的对应大写形式，tolower函数返回其参数的对应的小写形式。如果函数参数并不是处于一个适当的大小写的字符，函数将不修改直接返回。提示：直接测试或操纵字符将会降低程序的可移植性。例如，考虑下面这条语句，它试图测试ch是否是一个大写字符。if( ch >= "A" && ch <= "z" )这条语句在使用ASCII字符集的机器上能够运行，但是在使用EBCDIC字符集的机器上将会失败。另一方面，下面这条语句if ( isupper( ch ) )无论机器使用哪个字符集，它都能顺利进行，因此字符分类和转换函数可以提高函数的可移植性。1.8 内存操作 在非字符串数据中包含零值的情况并不罕见，此时无法使用字符串处理函数来处理这种类型的数据，因为当它们遇到第1个NUL字节时就停止工作。我们应该使用另外一组相关的函数，它们的操作与字符串函数类似，但这些函数能够处理任意的字符序列。下面是它们的原型：void *memcpy( void *dst, void const *src, size_t length );void *memmvoe( void *dst, void const *src, size_t length );void *memcmp( void const *a, void const *b, size_t length);void *memchr( void const *a, int ch, size_t length);void *memset( void *a, int ch, size_t length);每个原型都包含一个显示的参数说明需要处理的字节数，它们在遇到NUL字节时并不会停止工作。1.8.1 memcpyvoid *memcpy( void *dst, void const *src, size_t length ); memcpy从src的起始位置复制length个字节到dst的内存起始位置，我们可以使用这种方法复制任何类型的值。第3个参数length指定了复制值的长度(以字节计)。如果src和dst以任何形式出现重叠，其结果都是未定义的。例如：char temp[SIZE],value[SIZE];...memcpy( temp, value, SIZE);//从数组value复制SIZE个字节到temp如果两个数组为整型数组该怎么办？下面语句完成可以完成这项任务：memcpy( temp, value, sizeof(value) );memcpy()前两个参数类型是void*型指针，而任何类型的指针都可以转化为void*型指针。1.8.2 memmove void *memmvoe( void *dst, void const *src, size_t length ); memmove函数的行为和memcpy差不多，只是它的源和目标操作数可以重叠。它的内部实现过程：把源操作数复制到一个临时位置，这个临时的位置不会与源或目标操作数重叠，然后再把它从这个临时位置复制到目标操作数。如果源和目标参数真的可能存在重叠，就应该使用memmove，如下所示：//Shift the values int the x array left one position. memmove( x, x+1, ( count-1 ) * sizeof(x[0]) );1.8.3 memcmpvoid *memcmp( void const *a, void const *b, size_t length); memcmp对两段内存的内容进行比较，这两段内存分别起始于a和b，共比较length个字节。这些值按照无符号字符逐字进行比较，函数的返回值与strcmp函数一样。由于这些值是根据一串无符号字节进行比较的，所以memcmp函数用于比较不是单字节的数据如整数或浮点数时可能出现不可预料的结果。1.8.4 memchrvoid *memchr( void const *a, int ch, size_t length); memchr从a的起始位置开始查找字符ch第一次出现的位置，并返回一个指向该位置的指针，它共查找length个字节。如果在length个字节中未找到该字符，函数就返回NULL指针。1.8.5 memsetvoid *memset( void *a, int ch, size_t length); memset函数把从a开始的length字节都设置为字符值ch。例如：memset( buffer, 0, SIZE);//把buffer前SIZE个字节都初始化为‘"文章知识点与官方知识档案匹配C技能树字符串字符串输入与输出106612 人正在系统学习中打开CSDN，阅读体验更佳字符串、字符和字节三者关系： 字符串是由一个个字符组成的，每个字符又由一个或多个字节来表示，每个字节又由8个bit位来表示。 字符：计算机中使用的文字和符号，比如1、2、A、B、%等等。 字节（Byte）：一种计量单位，表示数据量多少，它是计算机信息技术用于计量存储容量的一种计量单位。 不同编码里，字符和字节的对应关系不同： ①ASCII码中，一个英文字母占一个字节的空间，一个中文汉字占两个字节的空间。 ②UTF-8编码中，一个英文字符等于一个字节，一个中文等于三个字节。 ③Unicode编码中，一个英文等于两个字节，一个中继续访问字符与字符串(新手，c语言)字符与字符串，新手详细笔记，c语言继续访问最新发布 字符串(字节)长度计算一般英文占一个长度，汉字占两个长度（字节），获取中英混合的字符串长度。继续访问热门推荐 字节，字符及占用内存大小情况（一）“字节”的定义 字节（Byte）是一种计量单位，表示数据量多少，它是计算机信息技术用于计量存储容量的一种计量单位。 （二）“字符”的定义 字符是指计算机中使用的文字和符号，比如1、2、3、A、B、C、~！·#￥%……—*（）——+、等等。 （三）“字节”与“字符” 它们完全不是一个位面的概念，所以两者之间没有“区别”这个说法。不同编码里，字符和字节的对应关系不同：继续访问c语言字符串长度，占用字节大小，存放位置等问题参考文章：https://www.cnblogs.com/xmhsincere/p/4915354.html 1、三者长度strlen问题 int main () { char *str="xiaolong"; printf("%d ",strlen(str)); return 0; } 结果： #include <stdio.h> #include <string.h> int main ...继续访问Linux 中与字符串相关的函数strpbrk、strcasecmp、strspn（不间断更新）本篇博客旨在整理出所有Linux网络编程中常用的字符串相关的函数，这些函数普遍用在处理网络通信中的字符串数据。话不多说，直接进入正题。 1、strpbrk函数 #include<string.h> char* strpbrk(char* s1, char* s2); strpbrk()从第一个字符指针指向的位置 向后检查每个字符，直到遇到（不检查），如果检查到的某个字符在s2指向的字符串中，那么返回他的地址，并停止检查。 如果s1 、s2没有相同字符，返回NULL。 注：传入strpb继续访问Linux下对字符串处理的实现函数（一）1.Linux下字符串大小写转换 2.Linux下删除字符串中对应标志字符串的首字符串 3.Linux下删除字符串中不需要的空格（示例:逗号前后） 5.Linux下处理字符串——忽略双引号内容 6.Linux下字符串分割——忽略双引号内容.........继续访问linux 纯字符串,Linux下常用的字符串函数13. strlen()(返回字符串长度)相关函数表头文件 #include定义函数 size_t strlen (const char *s);函数说明 strlen()用来计算指定的字符串s的长度，不包括结束字符""。返回值 返回字符串s的字符数。范例#includemain(){char *str = "12345678";printf("str length = %d "...继续访问linux 字符串操作函数1 strchr 函数原型：extern char *strchr(char *str,char character) 参数说明：str为一个字符串的指针，character为一个待查找字符。 所在库名：#include <string.h> 函数功能：从字符串str中寻找字符character第一次出现的位置。 返回说明：返回指向第一次出现字符cha...继续访问linux下字符串操作,Linux shell 字符串操作详解-Fun言1、Linux shell 截取字符变量的前8位实现方法有如下几种：expr substr “$a” 1 8echo $a|awk ‘{print substr(,1,8)}"echo $a|cut -c1-8echo $expr $a : ‘(.\).*"echo $a|dd bs=1 count=8 2>/dev/null2、按指定的字符串截取(1)第一种方法:从左向右截取最后一个s...继续访问Linux操作字符串目录 获取字符串长度： 提取子字符串： 子字符串消除 字符串替换 子字符串所在位置 获取字符串长度： 从字符串开始的地方匹配子字符串的长度： 1.expr match "$string" "$substring" 2.expr "$string" : "$substring 注释：$substring是一个正则表达式 提取子字符串： 1.${string:position} 在string 中从位置$position 开始提取子字符串. 如果$string为"*"或"@",继续访问Linux字符串操作Linux字符串操作 描述 shell内置一系列的操作符合，可以对字符串进行操作； 常用操作 表达式 含义 ${#string} $string的长度 ${string:position} 在string中从位置position开始提取子串 ${string:position:length} 在string中从位置position开始提取长度为$length的子串 ${string#substring} 从变量string的开头删除最短匹配substring的子串 ${s继续访问linux 字符串比较、数值比较字符串相等： [[ $str1 == $str2 ]] 字符串不相等： [[ $str1 != $str2 ]] 字符串大小比较： [[ $str1 > $str2 ]] 字符串等于空： [[ -z $str2 ]] 字符串不等于空： [[ -n $str2 ]] 二元比较操作符,比较变量或者比较数字.注意数字与字符串的区别. 整数比较 -eq 等于,如:if [ "$a" -eq "$b" ] -ne继续访问Linux下常用的字符串函数合集分享转自：Linux下常用的字符串函数一、字符间的转换1 tolower（将大写字母转换成小写字母）相关函数isalpha，toupper表头文件 include定义函数int tolower(int c);函数说明。。。https://www.pinlue.com/article/2019/04/1316/558651446754.html ...继续访问字符串(Linux应用编程篇)关于字符串的相关操作有 输入、输出、合并、修改、比较、转换、复制、搜索等等 一、字符串I/O 宏定义文件指针：标准输入设备stdin、标准输出设备stdout、标准错误设备stderr 字符串输出 putchar()、puts()、fputc()、fputs()这些函数也是标准 I/O 函数,标准C库函数，且应层的函数是有缓冲的，性能和效率要比系统调用要高。 /* @ puts函数 @ 头文件：#include <stdio.h> @ s：需要进行输出的字符串 @ 返回值：成功返回一继续访问Linux下的基本C编程的三类高频函数操作第二类——字符串操作函数（str）一，strlen和sizeof strlen一般用来求字符串长度，而sizeof是求这一段储存空间的大小。它们的区别在于strlen不计算空白符的大小，且遇到就会停止工作。 例如 #include <stdio.h> #include <string.h> int main(int argc, char **argv) { printf("%ld ",strlen("hello baby"));//结果为10； printf("%ld继续访问linux shell 函数返回字符串,如何从Bash函数返回字符串值您可以让函数将变量作为第一个arg，然后使用要返回的字符串修改变量。#!/bin/bashset -xfunction pass_back_a_string() {eval "$1="foo bar rab oof""}return_var=""pass_back_a_string return_varecho $return_var打印“ foo bar rab oof”。编辑：在适当的位置添加...继续访问字符串长度与字节个数在纯ASCII码下，字节数=字符串长度=字符个数，因为每个字符就一个字节。 在Unicode下，字节数/2=字符串长度=字符个数，因为每个字符都是2个字节。 在ASCII码与其它双字节字符系统混用时，字节数=ASCII码字符个数+双字节字符个数*2，而此时字符串长度到底怎么统计就不好说了，有的语言如C语言，此时字符串长度=字节数，有的语言如JS，此时字符产长度=字符个数。继续访问Linux 常用C函数(内存及字符串操作篇2)Linux 常用C函数(内存及字符串操作篇2)2007-03-22 11:36 strcat（连接两字符串）继续访问cc++字符串处理写评论评论1

作为一个C程序员，对 scanf,sscanf,fscanf printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离...

strchr() 是 <string.h> 中定义的一个函数，直接调用即可。

char *strcpy(char *dest,const char *src){if(dest==NULL||src==NULL)return NULL;if(dest==src)return dest;char *temp=dest;while((*dest==*stc++)!="")retrun temp;}

给你个单词替换的例子，稍微改改就可以达到你的要求了。/* Filename: word-replace.c * Description: 替换文件中指定的单词为其他字符串并输出到指定的文件中 */#include<stdio.h>#include<stdlib.h>#include<string.h>#include<ctype.h>#define MAX_WORDS_LEN 50 // 单词的最大长度限制typedef enum { FALSE = 0, TRUE = 1 } BOOL;struct Word { char str[MAX_WORDS_LEN + 1]; // 存储字符串 BOOL isWord; // 是否为单词};typedef struct Node { // 使用链表存储解析后的字符串 struct Word word; struct Node *next;} *List;enum Option { // 单词替换选项 MATCH_WORD_CASE, // 精确匹配单词区分大小写 MATCH_WORD_NOCASE, // 匹配单词但不区分大小写};// 函数功能：出错处理方法，打印出错信息并退出程序void complain(const char *msg){ printf("%s ", msg); exit(EXIT_FAILURE);}// 函数功能：将结构体单词 w 插入不带头节点的单向不循环链表 L 的末尾// 参数L：不带头节点的单向不循环链表的表头指针// 参数w：指向待插入链表 L 的结构体单词信息的指针void insert_list(List * L, const struct Word *w){ struct Node *node = (struct Node *)malloc(sizeof(struct Node)); node->word = *w, node->next = NULL; if (*L != NULL) { // 链表非空，则寻找链表的末尾并插入 struct Node *p; for (p = *L; p->next != NULL; p = p->next) ; p->next = node; } else // 链表为空，直接插入 *L = node;}// 函数功能：打印不带头节点的单向不循环链表，参数L为该链表的表头指针void print_list(List L){ for (struct Node * p = L; p; p = p->next) printf("%s|%d ", p->word.str, p->word.isWord);}// 函数功能：销毁不带头节点的单向不循环链表，参数L为该链表的表头指针void dump_list(List L){ for (struct Node * p = L, *n; p; p = n) { n = p->next; free(p); }}// 函数功能：不区分大小写的字符串比较函数，该函数不是标准C语言的库函数int stricmp(const char *dst, const char *src){ int ch1, ch2; do { if (((ch1 = (unsigned char)(*(dst++))) >= "A") && (ch1 <= "Z")) ch1 += 0x20; if (((ch2 = (unsigned char)(*(src++))) >= "A") && (ch2 <= "Z")) ch2 += 0x20; } while (ch1 && (ch1 == ch2)); return (ch1 - ch2);}// 函数功能：解析文件指针fp_ro所指文件中的字符串，将其中的单词和非单词分离// 出来，并将分离的结果存储到不带头节点的单向不循环链表L中。如果// 函数成功执行，返回TRUE，否则返回FALSE。BOOL word_parse(FILE * fp_ro, List * L){ if (fseek(fp_ro, 0L, SEEK_END)) return FALSE; const long fsize = ftell(fp_ro); if (fseek(fp_ro, 0L, SEEK_SET)) return FALSE; char *buf = (char *)malloc(fsize + 1); if (buf && fread(buf, fsize, 1, fp_ro) != 1 && ferror(fp_ro)) complain("Internal error."); struct Word w; char pword[MAX_WORDS_LEN + 1]; for (size_t i = 0, index = 0; i < (size_t) fsize;) { index = 0; while (!isalpha(buf[i]) && i < (size_t) fsize) { // 非字母 pword[index++] = buf[i++]; if (index == MAX_WORDS_LEN) { // 缓冲区溢出情况的处理 pword[index] = ""; // strncpy不自动添加"" strncpy(w.str, pword, index + 1); w.isWord = FALSE; insert_list(L, &w); index = 0; } } if (index != 0) { pword[index] = ""; // strncpy不自动添加"" strncpy(w.str, pword, index + 1); w.isWord = FALSE; insert_list(L, &w); } index = 0; while (isalpha(buf[i]) && i < (size_t) fsize) { // 单词 pword[index++] = buf[i++]; if (index == MAX_WORDS_LEN) // 缓冲区溢出情况的处理 complain("Too long word in source file."); } if (index != 0) { pword[index] = ""; // strncpy不自动添加"" strncpy(w.str, pword, index + 1); w.isWord = TRUE; insert_list(L, &w); } } free(buf); return TRUE;}// 函数功能：根据替换选项opt，替换在不带头节点的单向不循环链表L中的// 单词fnd为新的字符串rep，并返回替换的次数。int word_replace(List L, enum Option opt, const char *fnd, const char *rep){ int rep_cnt = 0; // 替换发生的次数 switch (opt) { case MATCH_WORD_CASE: for (struct Node * p = L; p; p = p->next) if (p->word.isWord == TRUE && strcmp(p->word.str, fnd) == 0) strcpy(p->word.str, rep), rep_cnt++; break; case MATCH_WORD_NOCASE: for (struct Node * p = L; p; p = p->next) if (p->word.isWord == TRUE && stricmp(p->word.str, fnd) == 0) strcpy(p->word.str, rep), rep_cnt++; break; default: fprintf(stderr, "Invalid option for function %s.", __func__); } return rep_cnt;}// 函数功能：将不带头节点的单向不循环链表 L 中的单词（字符串）按顺序存入由// fp_wr所指的文件中。如果函数成功执行，返回TRUE，否则返回FALSE。BOOL word_save(FILE * fp_wr, List L){ if (fseek(fp_wr, 0L, SEEK_SET)) return FALSE; for (struct Node * p = L; p; p = p->next) fprintf(fp_wr, "%s", p->word.str); return TRUE;}// 程序功能：以文件为单位，执行单词替换// 参数格式：命令 源文件 目标文件 查找的单词 替换的单词int main(int argc, const char *argv[]){ // 参数合法性检查 if (argc != 5 || strcmp(argv[1], argv[2]) == 0 || strlen(argv[3]) > MAX_WORDS_LEN || strlen(argv[4]) > MAX_WORDS_LEN) complain("参数错误！ " "参数格式：命令 源文件 目标文件 查找的单词 替换的单词"); FILE *fin = fopen(argv[1], "rt"); FILE *fout = fopen(argv[2], "wt"); const char *const fnd = argv[3]; const char *const rep = argv[4]; if (fin == NULL || fout == NULL) complain("文件输入输出错误！ "); List L = NULL; // 不带头结点的单向链表的表头指针 if (word_parse(fin, &L) == FALSE) complain("Parse error."); print_list(L); int rep_cnt = word_replace(L, MATCH_WORD_CASE, fnd, rep); printf("共发生替换 %d 次。 ", rep_cnt); word_save(fout, L); dump_list(L); fclose(fin); fclose(fout); return 0;}

#include #include using namespace std;int main() {int t = 0, i, temp;ifstream file("q.txt");streampos fsize = file.tellg(); // 得到文件位置file.seekg(0, ios::end); // 定位至文件末端size_t filesize = file.tellg() - fsize; // 相差值为文件大小file.seekg(fsize); // 返回文件开头char* str = new char[filesize + 1]; // 开空间，注意 + 1file.getline(str, filesize + 1);cout << str << endl;for (i = 0; i < strlen(str) + 1; i++) {if (str[i] == " " || str[i] == "") {temp = i;char *string = new char[temp - t + 1]; // 这里注意 + 1strncpy(string, str + t, temp - t);string[temp - t] = ""; // 补回null终结符cout << string << endl;t = i + 1;}}}

。。。。。。。。恭喜楼主。。。。。。对了。~

strcopy

void str2cpy(char *s,char *d){ while(*s) { *d++=*s++; if(!*s) break; s++; } *d=0;}

函数不是这个啊 是 strncpy 你少了个N

1）字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度字符串 strlen(p) 取字符串长度 strcmp(p, p1) 比较字符串 strcasecmp忽略大小写比较字符串strncmp(p, p1, n) 比较指定长度字符串 strchr(p, c) 在字符串中查找指定字符 strrchr(p, c) 在字符串中反向查找 strstr(p, p1) 查找字符串 strpbrk(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找该集合的任一元素 strspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找不属于该集合的任一元素的偏移 strcspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找属于该集合的任一元素的偏移 * 具有指定长度的字符串处理函数在已处理的字符串之后填补零结尾符 2）字符串到数值类型的转换 strtod(p, ppend) 从字符串 p 中转换 double 类型数值，并将后续的字符串指针存储到 ppend 指向的 char* 类型存储。strtol(p, ppend, base) 从字符串 p 中转换 long 类型整型数值，base 显式设置转换的整型进制，设置为 0 以根据特定格式判断所用进制，0x, 0X 前缀以解释为十六进制格式整型，0 前缀以解释为八进制格式整型atoi(p) 字符串转换到 int 整型 atof(p) 字符串转换到 double 符点数 atol(p) 字符串转换到 long 整型 3）字符检查 isalpha() 检查是否为字母字符 isupper() 检查是否为大写字母字符 islower() 检查是否为小写字母字符 isdigit() 检查是否为数字 isxdigit() 检查是否为十六进制数字表示的有效字符 isspace() 检查是否为空格类型字符 iscntrl() 检查是否为控制字符 ispunct() 检查是否为标点符号 isalnum() 检查是否为字母和数字 isprint() 检查是否是可打印字符 isgraph() 检查是否是图形字符，等效于 isalnum() | ispunct()

额

strstr

char * right(char *dst,char *src, int n){char *p = src;char *q = dst;int len = strlen(src);if(n>len) n = len;p += (len-n);while(*q++ = *p++);return dst;}

float match(char *str1,char *str2){ int i=0,j=0; char b1[10]=""; char *s1=str1;//v11(123)v234(23.2)v345(321) char *s2=str2; strcat(s2,"(");//标识后插入"(" while((*s1!="")&&(j==0)) { if((*s1)==(*s2))//如果完整串第一个字符与字串字符相等 { i=0; while(*(s1+i)==*(s2+i))// { i++; } if(*(s2+i)=="")//全部匹配完 { while(*(s1+i)!=")") { b1[j]=*(s1+i); i++; j++; } } else { while(*s1!=")")//不匹配直接跳到下一组标识前的")" s1++; s1++;//指针指到下一个标识第一个字符 } } else { while((*s1)!=")")//不匹配直接跳到下一组标识前的")" s1++; s1++;//指针指到下一个标识第一个字符 } } return atof(b1);}

方法没有错 问题在于 strncpy(b,a,6);执行之后 没有在结尾处添加字符串结束标志

方法没有错问题在于strncpy(b,a,6);执行之后没有在结尾处添加字符串结束标志

//调用字符串 IDS_ABOUTBOXCString ss ; ss.LoadString( IDS_ABOUTBOX ) ; AfxMessageBox( _T("字符串为 ") + ss ) ;

1. 如何把一个字符指针指向的字符串复制给字符数组 假如有char *p且p已指向一含有10个元素的字符数组，现有目标数组char b[10]，则可以有三种函数可以实现字符串复制。 1、strcpy 语法格式： strcpy（目标地址，源地址） 此例语法：strcpy(b,p);将源地址后的字符逐一复制到目标地址中，直到遇到结束符，如果源串中不含结束符就会造成目标数组越界。 2、strncpy 语法格式：strncpy（目标地址，源地址，字符长度） 此例语法：strncpy(b,p,10); 将源地址开始前n个（指定字符长度）字符逐一复制到目标地址中，不检测结束符也不检测边界，当指定长度大于目标数组长度则会越界。 3、memcpy 语法格式：memcpy（目标地址，源地址，字节长度） 此例语法：memcpy(b,p,sizeof(char)*10); 内存数据块复制，执行效率最高的一个。将源地址开始前n个（指定字符长度*字符的数据宽度）字节的内容复逐一复制到目标地址中，无视数组元素类型，只按字节复制，不检测数组边界，当指定长度大于目标数组长度则会越界。这里需要注意的是数组长度必须通过给定的元素类型获得数据宽度（sizeof(char)）然后计算出实际的内存大小。 2. 怎么将指针指向的字符串赋值给数组 #include<stdio.h> #include<string.h> char *copystr(const char*s1,char p1[100]) { int i=0; while(s1[i]!="") { p1[i]=s1[i]; i++; } p1[i]=""; return p1; } int main() { const char *s="hello! what are you doing?"; char p[100]; char *q; q=(char*)s；这句话直接把s的地址赋值给q copystr(s,p)；这个是函数一个一个赋值 puts(p); puts(q); return 0; } 3. 如何把一个字符指针指向的字符串复制给字符数组 假如有char *p且p已指向一含有10个元素的字符数组，现有目标数组char b[10]，则可以有三种函数可e799bee5baa6e58685e5aeb931333339666639以实现字符串复制。 1、strcpy语法格式： strcpy（目标地址，源地址）此例语法：strcpy(b,p)；将源地址后的字符逐一复制到目标地址中，直到遇到结束符，如果源串中不含结束符就会造成目标数组越界。2、strncpy语法格式：strncpy（目标地址，源地址，字符长度）此例语法：strncpy(b,p,10)；将源地址开始前n个（指定字符长度）字符逐一复制到目标地址中，不检测结束符也不检测边界，当指定长度大于目标数组长度则会越界。 3、memcpy语法格式：memcpy（目标地址，源地址，字节长度）此例语法：memcpy(b,p,sizeof(char)*10）；内存数据块复制，执行效率最高的一个。将源地址开始前n个（指定字符长度*字符的数据宽度）字节的内容复逐一复制到目标地址中，无视数组元素类型，只按字节复制，不检测数组边界，当指定长度大于目标数组长度则会越界。 这里需要注意的是数组长度必须通过给定的元素类型获得数据宽度（sizeof(char)）然后计算出实际的内存大小。 4. C语言中如果将一个指针所指向的字符串赋给数组 数组声明的时候就要指定大小的 可以用memcpy，对于字符串，也可以用strcpy或strncpy（需要包含string.h） 比如： char *p="abc"; char a[10]; memcpy(a,p,sizeof(a)); 或者 strcpy(a,p); 或者 strncpy(a,p,sizeof(a)）；/* 比上面的strcpy安全 */ PS：关于sizeof，取数组的时候是数组的大小，指针的话，32位机器，会是4，所以字符串指针不用sizeof取长度，用strlen(); 5. 怎么将指针得到的数据传递给数组 主要是指针数组与数组指针的区别 定义 int (*p)[n]；这个是数组指针 （）优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。 也就是说执行p+1时，p要跨过n个整型数据的长度 定义 int *p[n]；这个是指针数组 []优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组，它有n个指针类型的数组元素。这里执行p+1是错误的，这样赋值也是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]。 p[n-1]，而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a； 这里*p表示指针数组第一个元素的值，a的首地址的值。

用strncpy函数，函数签名char * strncpy(char *dest, const char *src, size_t n);比如要是从src第2个字符开始截取3个字符，可以用strncpy(dest, src + 2 - 1, 3);

1、puts函数——输出字符串的函数　　一般的形式为puts(字符串组)　　作用：将一个字符串输出到终端。如，char一个string，并赋予初值。调用puts(string);进行字符串的输出。　　2、gets函数——输入字符串的函数　　一般的形式：gets(字符数组)　　作用：从终端输入一个字符串到字符数组，并且得到一个函数值成为字符数组的起始地址。　　gets(str);　　键盘输入，，，，你懂得。　　注意：puts和gets函数只能输出或者输入一个字符串。　　3、strcat函数——字符串连接函数　　一般的形式：strcat(字符数组1，字符数组2);　　作用：把两个字符串数组中字符串连接起来，把字符串2连接到字符串1的后面。　　说明：字符数组1必须足够大，以便容纳连接后的新字符串。　　4、strcpy/strncpy函数——字符串复制函数　　一般形式：strcpy(字符数组1，字符串2);　　作用：将字符串2复制到字符数组1中去。　　如：char str1[10],str2[]="DongTeng";　　strcpy(str1,str2);　　执行后的结果为：你懂得　　注意：　　1. 不能用赋值语句直接将一个字符串常量或者字符数组直接给一个字符数组。　　2. 用strncpy可以赋值指定的位置的字符。strncpy(str1,str2,3);将str2中的第3个字符复制到str1中。　　5、strcmp函数——字符串比较函数　　一般形式：strcmp(字符串1，字符串2);　　作用：用来比较两个字符串的差异。具有不同的比较规则。　　6、strlen函数——测字符串长度的函数　　一般形式：strlen(字符数组);　　如：char str[10]="DongTeng";　　printf("%d",strlen(str));　　得到的结果是：5　　7、strlwr函数——转换为小写的函数　　一般形式：strlwr(字符串);　　8、strupr函数——转换为大写的函数　　一般形式：strupr(字符串)。

修改字符串字面量是几个意思啊。。

假如有char *p且p已指向一含有10个元素的字符数组，现有目标数组char b[10]，则可以有三种函数可以实现字符串复制。1、strcpy语法格式： strcpy(目标地址，源地址)此例语法：strcpy(b,p);将源地址后的字符逐一复制到目标地址中，直到遇到结束符，如果源串中不含结束符就会造成目标数组越界。2、strncpy语法格式：strncpy(目标地址，源地址，字符长度)此例语法：strncpy(b,p,10);将源地址开始前n个（指定字符长度）字符逐一复制到目标地址中，不检测结束符也不检测边界，当指定长度大于目标数组长度则会越界。3、memcpy语法格式：memcpy(目标地址，源地址，字节长度）此例语法：memcpy(b,p,sizeof(char)*10);内存数据块复制，执行效率最高的一个。将源地址开始前n个（指定字符长度*字符的数据宽度）字节的内容复逐一复制到目标地址中，无视数组元素类型，只按字节复制，不检测数组边界，当指定长度大于目标数组长度则会越界。这里需要注意的是数组长度必须通过给定的元素类型获得数据宽度（sizeof(char)）然后计算出实际的内存大小。

strncpy 是 C语言的库函数之一，来自 C语言标准库，定义于 string.h，char *strncpy(char *dest, const char *src, int n)，把src所指向的字符串中以src地址开始的前n个字节复制到dest所指的数组中，并返回dest 你这句话的意思是 因为b+3了所以是把b字符串第三个字符起后面三个字符复制到a比如b是123456789 那么复制之后是456到a

事实上，说正则表达式里不支持逆向匹配并不是百分之百的正确。就像这个问题，我们就可以使用否定式查找来模拟出逆向匹配，从而解决我们的问题：复制代码代码如下:^((?!hede).)*$上面这个表达式就能过滤出不包含‘hede"字串的信息。我上面也说了，这种写法并不是正则表达式“擅长”的用法，但它是可以这样用的。解释一个字符串是由n个字符组成的。在每个字符之前和之后，都有一个空字符。这样，一个由n个字符组成的字符串就有n+1个空字符串。我们来看一下“ABhedeCD”这个字符串：所有的e编号的位置都是空字符。表达式(?!hede).会往前查找，看看前面是不是没有“hede”字串，如果没有(是其它字符)，那么.(点号)就会匹配这些其它字符。这种正则表达式的“查找”也叫做“zero-width-assertions”(零宽度断言)，因为它不会捕获任何的字符，只是判断。在上面的例子里，每个空字符都会检查其前面的字符串是否不是‘hede"，如果不是，这.(点号)就是匹配捕捉这个字符。表达式(?!hede).只执行一次，所以，我们将这个表达式用括号包裹成组(group)，然后用*(星号)修饰——匹配0次或多次：复制代码代码如下:((?!hede).)*。你可以理解，正则表达式((?!hede).)*匹配字符串"ABhedeCD"的结果false，因为在e3位置，(?!hede)匹配不合格，它之前有"hede"字符串，也就是包含了指定的字符串。在正则表达式里，?!是否定式向前查找，它帮我们解决了字符串“不包含”匹配的问题。以下是一些补充：分享下php生成随机数的三种方法，生成1-10之间的不重复随机数，php生成不重复随机数的例子，需要的朋友参考下。在hackernews上看到regexgolf，几道很有趣的正则表达式的题，有的需要用到不匹配这种匹配，比如需要匹配不包含某个单词的串。开始正题之前，先来看看正则表达式的语法：[abc]a或b或c.任意单个字符a?零个或一个a[^abc]任意不是abc的字符s空格a*零个或多个a[a-z]a-z的任意字符S非空格a+一个或多个a[a-zA-Z]a-z或A-Zd任意数字a{n}正好出现n次a^一行开头D任意非数字a{n,}至少出现n次a$一行末尾w任意字母数字或下划线a{n,m}出现n-m次a(...)括号用于分组W任意非字母数字或下划线a*?零个或多个a(非贪婪)(a|b)a或b单词边界(a)...1引用分组(?=a)前面有a(?!a)前面没有aB非单词边界正则表达式中有(?=a)和(?!a)来表示我们是否需要匹配某个东西。所以，有需要不匹配某样内容时，就可以用(?!a)了。比如要匹配不含hello的字符串就可以这样写。复制代码代码如下:^(?!.*hello)这里.*用来表示hello之前可能有其他的字符，为什么还要加^呢，因为如果不加的话，可能匹配到h之后的这个位置上了。现在就可以解决regexgolf上的abba这道题了。这道题是去匹配不含abba这种形式的单词，比如abba，anallagmatic就不应该匹配上。正则表达式代码：复制代码代码如下:^(?!.*(.)(.)21)然后利用不匹配，还可以解决prime这道题，这道题匹配有素数个x的串，先看正则。复制代码代码如下:^(?!(xx+)1+$)(xx+)是匹配2个及2个以上的x，(xx+)1+就是匹配重复出现2个及以上的串，所以(xx+)1+就表示了那些非素数的串，那么素数串就是除去这些非素数串，即是以上的正则表达式了。

^.{3}4.*$3代表你想从第几个开始匹配，4代表你想匹配的字符。

end

按照你的要求给出的Java正则表达式的例子如下//下面这个正则表达式匹配不能以.css,.html,.js,.json或者.xml结尾的字符串import java.util.regex.Matcher;import java.util.regex.Pattern;public class CC {public static void main(String[] args) {String s="xxxx.js.jss";//目标字符串String regex="((?!\.((css)|(html)|(js)|(json)|(xml))$).)+";//正则表达式Pattern p=Pattern.compile(regex);Matcher m=p.matcher(s);if(m.matches()){System.out.println("匹配");}else{System.out.println("不匹配");}}}

var reg = /^[^""]*$/;

他们最喜欢什么，答案除了稳定的系统和可以远程启动之外，十有八九的人会提到正则表达式；如果我们再问他们最头痛的是什么，可能除了复杂的进程控制和安装过程之外，还会是正则表达式。那么正则表达式到底是什么？如何才能真正的掌握正则表达式并正确的加以灵活运用？本文将就此展开介绍，希望能够对那些渴望了解和掌握正则表达式的读者有所助益。入门简介 简单的说，正则表达式是一种可以用于模式匹配和替换的强有力的工具。我们可以在几乎所有的基于UNIX系统的工具中找到正则表达式的身影，例如，vi编辑器，Perl或PHP脚本语言，以及awk或sed shell程序等。此外，象JavaScript这种客户端的脚本语言也提供了对正则表达式的支持。由此可见，正则表达式已经超出了某种语言或某个系统的局限，成为人们广为接受的概念和功能。 正则表达式可以让用户通过使用一系列的特殊字符构建匹配模式，然后把匹配模式与数据文件、程序输入以及WEB页面的表单输入等目标对象进行比较，根据比较对象中是否包含匹配模式，执行相应的程序。 举例来说，正则表达式的一个最为普遍的应用就是用于验证用户在线输入的邮件地址的格式是否正确。如果通过正则表达式验证用户邮件地址的格式正确，用户所填写的表单信息将会被正常处理；反之，如果用户输入的邮件地址与正则表达的模式不匹配，将会弹出提示信息，要求用户重新输入正确的邮件地址。由此可见正则表达式在WEB应用的逻辑判断中具有举足轻重的作用。 基本语法 在对正则表达式的功能和作用有了初步的了解之后，我们就来具体看一下正则表达式的语法格式。 正则表达式的形式一般如下： /love/ 其中位于“/”定界符之间的部分就是将要在目标对象中进行匹配的模式。用户只要把希望查找匹配对象的模式内容放入“/”定界符之间即可。为了能够使用户更加灵活的定制模式内容，正则表达式提供了专门的“元字符”。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符，可以用来规定其前导字符（即位于元字符前面的字符）在目标对象中的出现模式。 较为常用的元字符包括： “+”， “*”，以及 “?”。其中，“+”元字符规定其前导字符必须在目标对象中连续出现一次或多次，“*”元字符规定其前导字符必须在目标对象中出现零次或连续多次，而“?”元字符规定其前导对象必须在目标对象中连续出现零次或一次。 下面，就让我们来看一下正则表达式元字符的具体应用。 /fo+/ 因为上述正则表达式中包含“+”元字符，表示可以与目标对象中的 “fool”, “fo”, 或者 “football”等在字母f后面连续出现一个或多个字母o的字符串相匹配。 /eg*/ 因为上述正则表达式中包含“*”元字符，表示可以与目标对象中的 “easy”, “ego”, 或者 “egg”等在字母e后面连续出现零个或多个字母g的字符串相匹配。 /Wil?/ 因为上述正则表达式中包含“？”元字符，表示可以与目标对象中的 “Win”, 或者 “Wilson”,等在字母i后面连续出现零个或一个字母l的字符串相匹配。 除了元字符之外，用户还可以精确指定模式在匹配对象中出现的频率。例如， /jim/ 上述正则表达式规定字符m可以在匹配对象中连续出现2-6次，因此，上述正则表达式可以同jimmy或jimmmmmy等字符串相匹配。 在对如何使用正则表达式有了初步了解之后，我们来看一下其它几个重要的元字符的使用方式。 s：用于匹配单个空格符，包括tab键和换行符； S：用于匹配除单个空格符之外的所有字符； d：用于匹配从0到9的数字； w：用于匹配字母，数字或下划线字符； W：用于匹配所有与w不匹配的字符； . ：用于匹配除换行符之外的所有字符。 （说明：我们可以把s和S以及w和W看作互为逆运算） 下面，我们就通过实例看一下如何在正则表达式中使用上述元字符。 /s+/ 上述正则表达式可以用于匹配目标对象中的一个或多个空格字符。 /d000/ 如果我们手中有一份复杂的财务报表，那么我们可以通过上述正则表达式轻而易举的查找到所有总额达千元的款项。 除了我们以上所介绍的元字符之外，正则表达式中还具有另外一种较为独特的专用字符，即定位符。定位符用于规定匹配模式在目标对象中的出现位置。 较为常用的定位符包括： “^”, “$”, “” 以及 “B”。其中，“^”定位符规定匹配模式必须出现在目标字符串的开头，“$”定位符规定匹配模式必须出现在目标对象的结尾，定位符规定匹配模式必须出现在目标字符串的开头或结尾的两个边界之一，而“B”定位符则规定匹配对象必须位于目标字符串的开头和结尾两个边界之内，即匹配对象既不能作为目标字符串的开头，也不能作为目标字符串的结尾。同样，我们也可以把“^”和“$”以及“”和“B”看作是互为逆运算的两组定位符。举例来说： /^hell/ 因为上述正则表达式中包含“^”定位符，所以可以与目标对象中以 “hell”, “hello”或 “hellhound”开头的字符串相匹配。 /ar$/ 因为上述正则表达式中包含“$”定位符，所以可以与目标对象中以 “car”, “bar”或 “ar” 结尾的字符串相匹配。 /bom/ 因为上述正则表达式模式以“”定位符开头，所以可以与目标对象中以 “bomb”, 或 “bom”开头的字符串相匹配。 /man/ 因为上述正则表达式模式以“”定位符结尾，所以可以与目标对象中以 “human”, “woman”或 “man”结尾的字符串相匹配。 为了能够方便用户更加灵活的设定匹配模式，正则表达式允许使用者在匹配模式中指定某一个范围而不局限于具体的字符。例如： /[A-Z]/ 上述正则表达式将会与从A到Z范围内任何一个大写字母相匹配。 /[a-z]/ 上述正则表达式将会与从a到z范围内任何一个小写字母相匹配。 /[0-9]/ 上述正则表达式将会与从0到9范围内任何一个数字相匹配。 /([a-z][A-Z][0-9])+/ 上述正则表达式将会与任何由字母和数字组成的字符串，如 “aB0” 等相匹配。这里需要提醒用户注意的一点就是可以在正则表达式中使用 “()” 把字符串组合在一起。“()”符号包含的内容必须同时出现在目标对象中。因此，上述正则表达式将无法与诸如 “abc”等的字符串匹配，因为“abc”中的最后一个字符为字母而非数字。 如果我们希望在正则表达式中实现类似编程逻辑中的“或”运算，在多个不同的模式中任选一个进行匹配的话，可以使用管道符 “|”。例如： /to|too|2/ 上述正则表达式将会与目标对象中的 “to”, “too”, 或 “2” 相匹配。 正则表达式中还有一个较为常用的运算符，即否定符 “[^]”。与我们前文所介绍的定位符 “^” 不同，否定符 “[^]”规定目标对象中不能存在模式中所规定的字符串。例如： /[^A-C]/ 上述字符串将会与目标对象中除A，B，和C之外的任何字符相匹配。一般来说，当“^”出现在 “[]”内时就被视做否定运算符；而当“^”位于“[]”之外，或没有“[]”时，则应当被视做定位符。 最后，当用户需要在正则表达式的模式中加入元字符，并查找其匹配对象时，可以使用转义符“”。例如： /Th*/ 上述正则表达式将会与目标对象中的“Th*”而非“The”等相匹配。ASP中正则表达式的应用（一）一、正则表达式概述 二、正则表达式在VBScript中的应用 三、正则表达式在VavaScript中的应用 四、示例 五、总结一、正则表达式概述 如果原来没有使用过正则表达式，那么可能对这个术语和概念会不太熟悉。不过，它们并不是您想象的那么新奇。 请回想一下在硬盘上是如何查找文件的。您肯定会使用 ? 和 * 字符来帮助查找您正寻找的文件。? 字符匹配文件名中的单个字符，而 * 则匹配一个或多个字符。一个如 "data?.dat" 的模式可以找到下述文件：data1.dat、data2.dat等等。如果使用 * 字符代替 ? 字符，则将扩大找到的文件数量。"data*.dat" 可以匹配下述所有文件名：data.dat、data1.dat、data12.dat等等，尽管这种搜索文件的方法肯定很有用，但也十分有限。? 和 * 通配符的有限能力可以使你对正则表达式能做什么有一个概念，不过正则表达式的功能更强大，也更灵活。 在我们编写ASP程序时，经常会判断一个字符串的有效性，如；一个串是否是数字、是否是有效的Email地址等等。如果不使用正则表达式，那么判断的程序会很长，并且容易出错，如果使用正则表达式，这些判断就是一件很轻松的工作了。后面我们将介绍如何判断数字和Email地址的有效性。 在典型的搜索和替换操作中，必须提供要查找的确切文字。这种技术对于静态文本中的简单搜索和替换任务可能足够了，但是由于它缺乏灵活性，因此在搜索动态文本时就有困难了，甚至是不可能的。 使用正则表达式，能完成些什么事情呢？ 测试字符串的某个模式。例如，可以对一个输入字符串进行测试，看在该字符串是否存在一个电话号码模式或一个信用卡号码模式。这称为数据有效性验证。 替换文本。可以在文档中使用一个正则表达式来标识特定文字，然后可以全部将其删除，或者替换为别的文字。 根据模式匹配从字符串中提取一个子字符串。可以用来在文本或输入字段中查找特定文字。 例如，如果需要搜索整个 web 站点来删除某些过时的材料并替换某些HTML 格式化标记，则可以使用正则表达式对每个文件进行测试，看在该文件中是否存在所要查找的材料或 HTML 格式化标记。用这个方法，就可以将受影响的文件范围缩小到包含要删除或更改的材料的那些文件。然后可以使用正则表达式来删除过时的材料，最后，可以再次使用正则表达式来查找并替换那些需要替换的标记。 那么，正则表达式语法的语法是如何呢？ 一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符(称为元字符)组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。 这里有一些可能会遇到的正则表达式示例： /^[ ]*$/ "^[ ]*$" 匹配一个空白行。 /d-d/ "d-d" 验证一个ID 号码是否由一个2位数字，一个连字符以及一个5位数字组成。 /<(.*)>.*</1>/ "<(.*)>.*</1>" 匹配一个 HTML 标记。 二、正则表达式在VBScript中的应用 VBScript使用RegExp对象、Matches集合以及Match对象提供正则表达式支持功能。我们还是先看一个例子。<%Function RegExpTest(patrn, strng)Dim regEx, Match, Matches "建立变量。Set regEx = New RegExp "建立正则表达式。regEx.Pattern = patrn "设置模式。regEx.IgnoreCase = True "设置是否区分字符大小写。regEx.Global = True "设置全局可用性。Set Matches = regEx.Execute(strng) "执行搜索。For Each Match in Matches "遍历匹配集合。RetStr = RetStr & "Match found at position "RetStr = RetStr & Match.FirstIndex & ". Match Value is ""RetStr = RetStr & Match.Value & ""." & "<BR>"NextRegExpTest = RetStrEnd Functionresponse.write RegExpTest("[ij]s.", "IS1 Js2 IS3 is4")%>在这个例子中，我们查找字符串中有无is或者js这两个词，忽略大小写。运行的结果如下：Match found at position 0. Match Value is "IS1".Match found at position 4. Match Value is "Js2".Match found at position 8. Match Value is "IS3".Match found at position 12. Match Value is "is4".下面我们就介绍这三个对象和集合。 1、RegExp对象是最重要的一个对象，它有几个属性，其中： ○Global 属性，设置或返回一个 Boolean 值，该值指明在整个搜索字符串时模式是全部匹配还是只匹配第一个。如果搜索应用于整个字符串，Global 属性的值为 True，否则其值为 False。默认的设置为 False。 ○IgnoreCase 属性，设置或返回一个Boolean值，指明模式搜索是否区分大小写。如果搜索是区分大小写的，则 IgnoreCase 属性为 False；否则为 True。缺省值为 False。 ○Pattern 属性，设置或返回被搜索的正则表达式模式。必选项。总是一个 RegExp 对象变量。 2、Match 对象 匹配搜索的结果是存放在Match对象中，提供了对正则表达式匹配的只读属性的访问。 Match 对象只能通过 RegExp 对象的 Execute 方法来创建，该方法实际上返回了 Match 对象的集合。所有的 Match 对象属性都是只读的。在执行正则表达式时，可能产生零个或多个 Match 对象。每个 Match 对象提供了被正则表达式搜索找到的字符串的访问、字符串的长度，以及找到匹配的索引位置等。 ○FirstIndex 属性，返回在搜索字符串中匹配的位置。FirstIndex 属性使用从零起算的偏移量，该偏移量是相对于搜索字符串的起始位置而言的。换言之，字符串中的第一个字符被标识为字符 0 ○Length 属性，返回在字符串搜索中找到的匹配的长度。 ○Value 属性，返回在一个搜索字符串中找到的匹配的值或文本。 3、Matches 集合 正则表达式 Match 对象的集合。Matches 集合中包含若干独立的 Match 对象，只能使用 RegExp 对象的 Execute 方法来创建之。与独立的 Match 对象属性相同，Matches `集合的一个属性是只读的。在执行正则表达式时，可能产生零个或多个 Match 对象。每个 Match 对象都提供了与正则表达式匹配的字符串的访问入口、字符串的长度，以及标识匹配位置的索引。 学习了这三个对象和集合，如何应用于字符串的判断和替换呢？regExp对象的三个方法正好解决了这个问题，它们是Replace方法、Test方法和Execute方法。 1、Replace 方法 替换在正则表达式查找中找到的文本。我们还是先看个例子：下面的例子说明了 Replace 方法的用法。<%Function ReplaceTest(patrn, replStr)Dim regEx, str1 " 建立变量。str1 = "The quick brown fox jumped over the lazy dog."Set regEx = New RegExp " 建立正则表达式。regEx.Pattern = patrn " 设置模式。regEx.IgnoreCase = True " 设置是否区分大小写。ReplaceTest = regEx.Replace(str1, replStr) " 作替换。End FunctionResponse.write ReplaceTest("fox", "cat") & "<BR>" " 将 "fox" 替换为 "cat"。Response.write ReplaceTest("(S+)(s+)(S+)", "$3$2$1") " 交换词对.%> 2、Test 方法 对指定的字符串执行一个正则表达式搜索，并返回一个 Boolean 值指示是否找到匹配的模式。正则表达式搜索的实际模式是通过RegExp对象的Pattern属性来设置的。RegExp.Global属性对Test方法没有影响。 如果找到了匹配的模式，Test方法返回True；否则返回False。下面的代码说明了Test 方法的用法。<%Function RegExpTest(patrn, strng)Dim regEx, retVal " 建立变量。Set regEx = New RegExp " 建立正则表达式。regEx.Pattern = patrn " 设置模式。regEx.IgnoreCase = False " 设置是否区分大小写。retVal = regEx.Test(strng) " 执行搜索测试。If retVal ThenRegExpTest = "找到一个或多个匹配。"ElseRegExpTest = "未找到匹配。"End IfEnd FunctionResponse.write RegExpTest("is.", "IS1 is2 IS3 is4")%> 3、Execute 方法 对指定的字符串执行正则表达式搜索。正则表达式搜索的设计模式是通过 RegExp 对象的 Pattern 来设置的。 Execute 方法返回一个 Matches 集合，其中包含了在 string 中找到的每一个匹配的 Match 对象。如果未找到匹配，Execute 将返回空的 Matches 集合。三、JavaScript中正则表达式的使用 在JavaScript 1.2版以后，JavaScript也支持正则表达式。 1、replace replace在一个字符串中通过正则表达式查找替换相应的内容。replace并不改变原来的字符串，只是重新生成了一个新的字符串。如果需要执行全局查找或忽略大小写，那么在正则表达式的最后添加g和i。例：<SCRIPT>re = /apples/gi;str = "Apples are round, and apples are juicy.";newstr=str.replace(re, "oranges");document.write(newstr)</SCRIPT>结果是："oranges are round, and oranges are juicy." 例：<SCRIPT>str = "Twas the night before Xmas...";newstr=str.replace(/xmas/i, "Christmas");document.write(newstr)</SCRIPT>结果是："Twas the night before Christmas..." 例：<SCRIPT>re = /(w+)s(w+)/;str = "John Smith";newstr = str.replace(re, "$2, $1");document.write(newstr)</SCRIPT>结果是："Smith, John". 2、search search通过正则表达式查找相应的字符串，只是判断有无匹配的字符串。如果查找成功，search返回匹配串的位置，否则返回-1。 search(regexp)<SCRIPT>function testinput(re, str){ if (str.search(re) != -1)midstring = " contains ";elsemidstring = " does not contain ";document.write (str + midstring + re.source);}testinput(/^[1-9]/i,"123")

你写的代码有问题呗。。。Library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; entity atel2_bin is port( txclk: in std_logic; --2400Hz的波特率时钟 reset: in std_logic; --复位信号 din: in std_logic_vector(15 downto 0); --发送的数据 start: in std_logic; --允许传输信号 sout: out std_logic --串行输出端口 ); end atel2_bin; architecture behav of atel2_bin is signal thr,len: std_logic_vector(15 downto 0); signal txcnt_r: std_logic_vector(2 downto 0); --数据位计数 signal sout1: std_logic; signal cou: integer:=0; signal oddb:std_logic; type s is(start1,start2,shift1,shift2,odd1,odd2,stop1,stop2); signal state:s:=start1; begin process(txclk) begin if rising_edge(txclk) then if cou<3 then thr<=0000000001010101; --发送的文件头 elsif cou=3 then thr<=0000000000000010; --发送的文件长度 elsif (cou>3 and state=stop2) then thr<=din;--发送的数据 end if; end if; end process; process(reset,txclk) variable tsr,tsr1,oddb1,oddb2: std_logic_vector(7 downto 0); begin if reset=1 then txcnt_r<=(others=>0); sout1<=1; state<=start1; cou<=0; elsif txclkevent and txclk=1 then case state is when start1=> ----低8位 if start=1 then if cou=3 then len<=thr; end if; tsr:=thr(7 downto 0); oddb1:=thr(7 downto 0); sout1<=0; --起始位 txcnt_r<=(others=>0); state<=shift1; else state<=start1; end if; when shift1=> oddb<=oddb1(7) xor oddb1(6) xor oddb1(5) xor oddb1(4) xor oddb1(3) xor oddb1(2) xor oddb1(1) xor oddb1(0); sout1<=tsr(0); --数据位 tsr(6 downto 0):=tsr(7 downto 1); tsr(7):=0; txcnt_r<=txcnt_r+1; if (txcnt_r=7) then state<=odd1;cou<=cou+1; end if; when odd1=> --奇校验位 if oddb=1 then sout1<=0; state<=stop1; else sout1<=1; state<=stop1; end if; when stop1=> sout1<=1; --停止位 if cou<4 then state<=start1; else state<=start2; end if; when start2=> ----高8位 tsr1:=thr(15 downto 8); oddb2:=thr(15 downto 8); sout1<=0; --起始位 txcnt_r<=(others=>0); state<=shift2; when shift2=> oddb<=oddb2(7) xor oddb2(6) xor oddb2(5) xor oddb2(4) xor oddb2(3) xor oddb2(2) xor oddb2(1) xor oddb2(0); sout1<=tsr1(0); --数据位 tsr1(6 downto 0):=tsr1(7 downto 1); tsr1(7):=0; txcnt_r<=txcnt_r+1; if (txcnt_r=7) then state<=odd2; end if; when odd2=> --奇校验位 if oddb=1 then sout1<=0;state<=stop2; else sout1<=1;state<=stop2; end if; when stop2=> sout1<=1; --停止位 if len=0000000000000000 then state<=stop2; else state<=start1; len<=len-1; end if; end case; end if; end process; sout<=sout1; end behav;

int main(int argc, char** argv) {int max=100; //字符串长度int len;//输入字符串长度char str[max];char temp;//交换字符printf("请输入字符串：");scanf("%s",str);len=strlen(str);for(int i=0;i<len/2;i++){temp=str[i];str[i]=str[len-i-1];str[len-i-1]=temp;}printf("%s",str);return 0;}

你好！怎么删除fgets（.）取到的字符串末尾的换行符用strlen找到最后的字符cont[i][strlen(cont[i])-1]=0;即可如有疑问，请追问。

fgets （）是输入字符到程序中，要输出应该用printf（）之类的输出函数才可以。

1）如果要保存多行，必须要分配足够的内存，建议temp改成100*256这么大，假设每行最长256字节，最多100行。2）30字节对一行来说都太小了，更不用说对多行，很容易缓冲区溢出。你的buf至少也要搞到256字节一行，虽然以前说是80字节，但是你看看很多文件现在一行都远远超过了。

fgets函数从指定文件中读入一个字符串，存入字符数组中，并在结尾端自动加一个""。

#define string_length 100fgets(line,string_length,fp);

fgets(char* s, int size, FILE* stream) ：最多在stream中读取size-1个字符存入s指向的缓冲区。遇到EOF（文件结束符）或" "结束，（" "放入s中）并在末尾加个。

new 一个字符串数组，然后返回该变量就是

如果index函数没有在字符串中找到子串,则会返回-1

1、查询SQL中的所有表： Select TABLE_NAME FROM 数据库名称.INFORMATION_SCHEMA.TABLES Where TABLE_TYPE="BASE TABLE" 执行之后，就可以看到数据库中所有属于自己建的表的名称 2、查询SQL中所有表及列： Select dbo.sysobjects.name as Table_name, dbo.syscolumns.name AS Column_name FROM dbo.syscolumns INNER JOIN dbo.sysobjects ON dbo.syscolumns.id = dbo.sysobjects.id Where (dbo.sysobjects.xtype = "u") AND (NOT (dbo.sysobjects.name LIKE "dtproperties")) 3、在Sql查询分析器，还有一个简单的查询方法： EXEC sp_MSforeachtable @command1="sp_spaceused "?"" 执行完之后，就可以看到数据库中所有用户表的信息 4、查询总存储过程数:select count(*) 总存储过程数 from sysobjects where xtype="p" 附：xtype类型D = 默认值或 DEFAULT 约束F = FOREIGN KEY 约束L = 日志FN = 标量函数IF = 内嵌表函数P = 存储过程PK = PRIMARY KEY 约束（类型是 K）RF = 复制筛选存储过程S = 系统表TF = 表函数TR = 触发器U = 用户表UQ = UNIQUE 约束（类型是 K）V = 视图X = 扩展存储过程 另：在sqlserver中取得某个数据库中所有表名的sql语句 select sysobjects.name from sysobjects.xtype ="U";SELECT nameWHERE (xtype = "U") 在数据库的sysobjects表里有这个数据库全部表的信息, xtype值为"U"的就是表名 注意：一般通过上述方法获得全部用户表示都会有一个dtproperties表，SQLSERVER 默认它也是用户表，想要从用户表中排出，需要加上限定条件 status>0，即：select * from sysobjects where xtype="U" and status>0

CString strText = _T("Item_小猪,Item_小兔,Item_小蛇,Item_小猫,Item_小狗,Item_小青蛙,Item_小麻雀"); LPCTSTR szToken = _T("Item_,"); CString strToken(_T("")); int curPos = 0; int index = -1;//定义变量并初始化 while(_T("") != (strToken = strText.Tokenize(szToken, curPos))) { if(!strToken.IsEmpty()) { AfxMessageBox(strToken); index++;//每取出一个就+1 } }

使用CString的Tokenize函数，下面的例子来至MSDN 2008// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;CAtlString str(_T("%First Second#Third"));CAtlString resToken;int curPos = 0;resToken= str.Tokenize(_T("% #"),curPos);while (resToken != _T("")){ _tprintf_s(_T("Resulting token: %s "), resToken); resToken = str.Tokenize(_T("% #"), curPos);};

如有字符串"hello.world"，用"."去切割这个字符串，得到的结果却是空数组： 原因是split()是用正则去匹配切割字符串，.是正则的特殊符号，所以必须转义，用"."去切割： 另外，还可以用tokenize()方法去切割： spli()方法和tokenize()方法的对比可见如下url中的介绍： http://www.tothenew.com/blog/groovy-tokenize-vs-split/ 截图加注释如下：

CString a("This&is&a&samle&!"); CString b; CStringArray sa; int curPos = 0; b = a.Tokenize("&", curPos); while(!b.IsEmpty()) { sa.Add(b); TRACE(_T("%s "), sa[sa.GetSize() - 1]); b = a.Tokenize("&", curPos); }

回楼主。在tokenize里，这里有英文的参考文档import tokenizeimport StringIOs = StringIO.StringIO( "21.3e-5*-.1234/81.7" )g = tokenize.generate_tokens( s.readline )for tokenum, tokeval, _, _, _ in g: if tokenum == tokenize.NUMBER and "." in tokeval: result.extend( [( tokenize.NAME, "Decimal" ), ( tokenize.OP, "(" ), ( tokenize.STRING, repr( tokeval ) ), ( tokenize.OP, ")" )] ) else: result.append( ( tokenum, tokeval ) )print result这是我临时照抄的一个例子

一般都是数据类型错误。转换一下。贴出来代码我帮你看看也行。

日期格式化与字符串转换成时间（C＃.NET）yyyy 代表年MM 代表月（注意这里要用大写）dd 代表日HH/hh 代表时（24小时形式/12小时形式）mm 代表分（这里用小写表示分钟）ss 代表秒//======= 日期格式化成指定字符串 =======DateTime d = DateTime.now;d.toString("yyyyMMdd HHmmss"); //例如"20070529 094530"字符串格式d.toString("yyyy-MM-dd HH:mm:ss"); //例如"2007-05-29 09:45:30"字符串格式d.toString("yyyy年MM月dd日 HH:mm:ss"); //例如"2007年05月29日 09:45:30"字符串格式//======= 指定字符串转化成日期（DateTime）＝＝＝＝＝string str = "20070529094530";IFormatProvider format = new System.Globalization.CultureInfo("zh-CN");string TarStr = "yyyyMMddHHmmss"; //注意这里用到HHDateTime MyDate = DateTime.ParseExact(str, TarStr);

日期格式化与字符串e799bee5baa6e79fa5e9819331333363383465转换成时间（C＃.NET）yyyy代表年MM代表月（注意这里要用大写）dd代表日HH/hh代表时（24小时形式/12小时形式）mm代表分（这里用小写表示分钟）ss代表秒//=======日期格式化成指定字符串=======DateTimed=DateTime.now;d.toString("yyyyMMddHHmmss");//例如"20070529094530"字符串格式d.toString("yyyy-MM-ddHH:mm:ss");//例如"2007-05-2909:45:30"字符串格式d.toString("yyyy年MM月dd日HH:mm:ss");//例如"2007年05月29日09:45:30"字符串格式//=======指定字符串转化成日期（DateTime）＝＝＝＝＝stringstr="20070529094530";IFormatProviderformat=newSystem.Globalization.CultureInfo("zh-CN");stringTarStr="yyyyMMddHHmmss";//注意这里用到HHDateTimeMyDate=DateTime.ParseExact(str,TarStr);

python 如何将字符串转化为datetime.date需要分”字符串与time类型的转换“和”time类型与datetime类型的转换“两种情况。为了从字符串中提取时间，并进行比较，因此有了这个问题，如何将字符串转换成datetime类型1.字符串与time类型的转换>>> import time>>> timestr = "time2009-12-14">>> t = time.strptime(timestr, "time%Y-%m-%d")>>> print t(2009, 12, 14, 0, 0, 0, 0, 348, -1)>>> type(t)<type "time.struct_time">>>>如代码所示使用strptime进行转换，第一个参数是要转换的字符串，第二个参数是字符串中时间的格式与之对应的有函数strftime，是将time类型转换相应的字符串下面是格式化符号汇总%a 星期几的简写 Weekday name, abbr.%A 星期几的全称 Weekday name, full%b 月分的简写 Month name, abbr.%B 月份的全称 Month name, full%c 标准的日期的时间串 Complete date and time representation%d 十进制表示的每月的第几天 Day of the month%H 24小时制的小时 Hour (24-hour clock)%I 12小时制的小时 Hour (12-hour clock)%j 十进制表示的每年的第几天 Day of the year%m 十进制表示的月份 Month number%M 十时制表示的分钟数 Minute number%S 十进制的秒数 Second number%U 第年的第几周，把星期日做为第一天（值从0到53）Week number (Sunday first weekday)%w 十进制表示的星期几（值从0到6，星期天为0）weekday number%W 每年的第几周，把星期一做为第一天（值从0到53） Week number (Monday first weekday)%x 标准的日期串 Complete date representation (e.g. 13/01/08)%X 标准的时间串 Complete time representation (e.g. 17:02:10)%y 不带世纪的十进制年份（值从0到99）Year number within century%Y 带世纪部分的十制年份 Year number%z，%Z 时区名称，如果不能得到时区名称则返回空字符。Name of time zone%% 百分号2.time类型与datetime类型的转换这一步比较简单，使用datetime函数，代码如下>>> import datetime>>> d = datetime.datetime(* t[:6])>>> print d2009-12-14 00:00:00>>> type(d)<type "datetime.datetime">>>>备忘：＊表示将列表中的数据作为函数的参数，**表示将字典的数据作为函数的参数传入参考资料python 字符串和datetime转换.CSDN博客[引用时间2017-12-28]

转载标明出处：http://blog.csdn.net/haoel/archive/2006/11/19/1395358.aspx我相信，使用C/C++多年的人对下面这个字符串赋值语句都不会陌生吧。 char* p = "test";同时，我也相信，各位在使用这种语句后吃过很多苦头也不少吧？只要你想利用指针p来改变字符串的内容，你的程序都会得到一个让你颜面尽失一个内存非法操作。比如，下面的这些语句： p[0] = "s"; strcpy(p, "haoel");原因就在于，char* p = "test"; 这个声明，声明了一个指针，而这个指针指向的是全局的const内存区，const内存区当然不会让你想改就改的。所以，如果你一定要写这块内存的话，那就是一个非常严重的内存错误。另，之所以加粗“全局const内存区”，是强调一下，如果你不信的话，你可以试试下面这段代码，看看p1和p2的地址是不是一样的。 char* p1 = "anything"; char* p2 = "anything"; printf(“ p1=%x, p2=%x ”, p1, p2);我想这应该是一个众所周知的问题吧。取而代之的，应该是使用数组来做初始化声明。如：char str[] = “hello world”; 如果现在还有哪本书中的C的示例采用了使用const字符串初始化指针的这种方式，那么你就可以把那本书撕了，如果这本书是C++的书话，那么你应该把这个作者和这个出版社告上法庭，因为你不应该容忍这种学术骗子。如果你的部门的开发人员还有人写出这种代码的话，如果他是C程序员，我想你可以在打过他的屁股后告诉他下不为例，如果他是一个C++程序员的话，我想你可以怀疑他是否有资格做一个C++程序员了。 至于你问我为什么要对学C++的人那么苛刻，那是因为学过C++的人都知道C++中的const关键字的有着什么样的权力，你也应该知道C++对const有着无比的照顾和关爱，几乎所有关于C++的书都会提到const这东西。所以，如果作为一个C++的程序员来说，如果你不知道的话，那就太说不过去了。 我们知道，双引号引起来的字符串是const的，所以，在C++的世界中，你应该进行如下的声明才比较稳妥： const char *p = "test";这样，当你修改这个字符串的内容时，编译器会给你一个错误而导致你的程序编译不通过，从而不会产生运行时的内存错误。 可问题是，像C++这种对类型要求很严格的语言来说，为什么它在编译诸如char *p="test" 程序的时候不出错，甚至连个警告都没有（g++和vc++7）？难道这是他的一个bug？我想，这应该是对古老的C的一个向下兼容。因为，在C的世界中，这种用法太多了。在C++中，比如：函数的参数和异常的捕获都存在这种问题，如下所示：（因编译器而定，在gcc 3.4.3版中，下例中的异常示例不能被捕获，但VC++6中却可以被捕获） func( char* p) { } // 以这种方式调用函数func(“abc”); try { thow “exception”; } catch (char* p) { } 这些都是C++编译器默认了可以把const char* 转成 char* 的罪行，无疑会对大家是一个误导。甚至让人无所畏惧地走入其中，并自以为走入了正途。这样看来，这种向下兼容的C++标准，就显得有点误人不浅了。 不过好在，C++标准委员会早已意识到了这一点。这个C++的feature被定义为了“Deprecated Feature”，即“不被建议使用的特性”。意思就是，在将来，这种特性将被从C++中移出，于是，你目前的这种程序将无法在新的C++编译器上编译通过。对于程序的可移植性来说，我们今天所写的代码尤其要注意这些“Deprecated Feature”。 据我所知，目前C++中被列为“Deprecated Feature”如下所示（可能不准确，请大家指正）下面的这些feature都已被C++标准委员会订为废除featrue了。一、 隐晦的字符串的const转换。char *p = "test";w_char *pw = L"test"; 把一个const的字符串类型转成non-const的。包括指针和数组。二、 隐晦的类型声明。func() {} //函数的隐晦返回类型是intstatic num; //变量的隐晦类型是int 这种feature在C89中还可以使用，但在C99和C++中都被去除了。（gcc 3.4版本对于这种声明会给出编译错误，而VC++6.0会认为这是合法的程序）三、 布尔变量的累加操作。bool isConn = false;isConn++; //这个操作会把isConn变为true就目前而言，几乎所有的编译器都认可这种操作，但这种用法也是不被建议的，终有一天会被取消。四、 更改父类成员的存取权限。class B{ protected: int i;};class D : public B{ public: B::i; //这种方式可能大家很少看到。}; 对于这种语法，子类重新暴露了父类的私有成员。这会带来很大的安全性问题。目前而言，这个feature对于所有的编译器来说应该都是可以编译通过的（连个Warning都没有）。但这个feature也是要被废除的。五、 文件中域的static声明static int i;static void func() 据说，这种旧的在C中的为了实现其作用域在本文件中的feature在未来的C++中也要被取消。文章到这里应该结束了，在结束之前，让我再给大家共享一个有趣的关于const的例子（在网上看到的） const int a = 1; int *p = const_cast<int*>(&a); *p = 2; cout << “value a=”<< a << endl; cout << “value *p=” <<*p << endl; cout << “address a=” <<&a << endl; cout << “address p=” <<p << endl;这段代码输出的结果如下：value a=1value *p=2address a=0xbff1d48caddress p=0xbff1d48c地址都是一样的，可值为什么不一样呢？呵呵。这个问题看起来有点“学术味”过浓，不过是个好例子，可以让你知道C++的一些用法和一些原理。有以下几个方面大家可以考虑一下：1）const int a = 1是不是和宏有点像，会不会被编译器优化了？2）去修改一个const的值，本来应该是不对的。这可能会是向旧的C兼容。是否会让编译器产生未知行为？所以，这个示例也告诉我们，我们应该遵循C++中的const和non-const的语义，任何想要破坏这个语义的事情都会给我们带来未知的结果。

单圆 还是任意方程曲线？

可能速度上有区别吧，memcpy应该最快

是否要将SYMBOL字体的190替换为××，其它字符190不换！如是，要设置替换高级选项，输入190，在下面 高级 格式 字体 内找到SYMBOL。然后替换为输入××

这个也比较简单，在word中用快捷键，Ctrl加f，然后切换到替换将星星，速到上面的地方，然后再将190放到下面，然后点击全部替换即可，希望可以帮到你