精华内容
下载资源
问答
  • C语言实现常见字符串操作函数

    千次阅读 2019-01-28 12:52:31
    常见字符串操作函数的实现 strlen函数 函数声明原型: size_t strlen( const char *string ); 函数功能: 计算指定的字符串string的长度,不包括结束字符’\0’,之后返回字符串string的长度 strlen函数实现...

    常见字符串操作函数的实现

    strlen()函数

    1. 函数声明原型:
    	size_t strlen( const char *string );
    
    1. 函数功能:
      计算指定的字符串string的长度。
    2. strlen函数实现:
    #include<stdio.h>
    #include<assert.h>
    #include<stdlib.h>
    
    size_t strlen(const char *string);
    size_t my_strlen1(const char* string)
    {
    	assert(string);
    	size_t count = 0;
    	while (*string++)
    	{
    		count++;
    	}
    	return count;
    }
    size_t my_strlen2(const char* string)
    {
    	assert(string);
    	if (*string == '\0')
    		return 0;
    	return 1 + my_strlen2(string + 1);
    }
    int main()
    {
    	char s[] = "abcdefg";
    	printf("%d\n", my_strlen2(s));
    	system("pause");
    	return 0;
    }
    

    strcpy()函数

    1. 函数声明原型:
    	char *strcpy( char *strDestination, const char *strSource );
    
    1. 函数功能:
      将参数src字符串拷贝至参数dest所指的地址。
    2. 函数实现:
    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    
    char* my_strcpy(char* dest, const char* src)
    {
    	assert(dest);
    	assert(src);
    	char* ptr = dest;
    	while (*src)
    	{
    		*dest++ = *src++;
    	}
    	*dest = *src;
    	return ptr;
    }
    int main()
    {
    	char s1[] = "abefg";
    	char s2[] = "cdefg";
    	printf("%s\n", my_strcpy(s1, s2));
    	system("pause");
    	return 0;
    }
    

    strcmp()函数

    1. 函数声明原型:
    	int strcmp( const char *string1, const char *string2 );
    
    1. 函数功能:
      字符串比较。
    2. 函数实现:
    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    
    int strcmp(const char *string1, const char *string2);//库函数原型
    
    int my_strcmp(const char* s1, const char* s2)
    {
    	assert(s1);
    	assert(s2);
    	char* e1 = s1;
    	char* e2 = s2;
    	while ((*e1 == *e2) && (*e1 != '\0') && (*e2 != '\0'))
    	{
    		e1++;
    		e2++;
    	}
    	if (*e1 > *e2)
    		return 1;
    	else if (*e1 < *e2)
    		return -1;
    	if (*e1 == *e2 == '\0')
    		return 0;
    }
    int main()
    {
    	char s1[] = "bcde";
    	char s2[] = "cde";
    	printf("%d\n", my_strcmp(s1, s2));
    	system("pause");
    	return 0;
    }
    

    strcat()函数

    1. 函数声明原型:
    	char *strcat( char *strDestination, const char *strSource );
    
    1. 函数功能:
      字符串拼接函数。
    2. 函数实现:
    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    
    char* my_strcat(char* dest, const char* src)
    {
    	assert(dest);
    	assert(src);
    	char* ptr = dest;
    	while (*dest != '\0')
    	{
    		dest++;
    	}
    	while (*dest++ = *src++);
    	*dest = *src;
    	return ptr;
    }
    int main()
    {
    	char s1[] = "abcdef";
    	char s2[] = "bcd";
    	printf("%s\n",my_strcat(s1, s2));
    	system("pause");
    	return 0;
    }
    

    strchr()函数

    1. 函数声明原型:
    	char *strchr( const char *string, int c );
    
    1. 函数功能:
      在一个字符串中查找给定字符的第一个匹配之处。
    2. 函数实现:
    #include<stdio.h>
    #include<assert.h>
    #include<stdlib.h>
    
    char* my_strchr(const char* dest, int c)
    {
    	assert(dest);
    	char* ptr = dest;
    	while (*ptr++ != c);
    	if (*ptr != '\0')
    		return --ptr;
    	else
    		return NULL;
    }
    int main()
    {
    	char s1[] = "abcdef";
    	char c = 'n';
    	printf("%s\n", my_strchr(s1, c));
    	system("pause");
    	return 0;
    }
    

    strstr()函数

    1. 函数声明原型:
     char *strstr( const char *string, const char *strCharSet );
    
    1. 函数功能:
      检索子串在字符串中首次出现的位置。
    2. 函数实现:
    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    
    char* my_strstr(char* dest, const char* src)
    {
    	assert(dest);
    	assert(src);
    	char* ptr1 = dest;
    	char* ptr2 = NULL;
    	while (*ptr1 != *src && *ptr1 != '\0')
    	{
    		ptr1++;
    		ptr2 = ptr1;
    	}
    	while (*ptr1 == *src)
    	{
    		ptr1++;
    		src++;
    	}
    	if (*src != '\0')
    		return NULL;
    	else
    		return ptr2;
    }
    int main()
    {
    
    	char s1[] = "abcdefg";
    	char s2[] = "mn";
    	printf("%s\n", my_strstr(s1, s2));
    
    	system("pause");
    	return 0;
    }
    

    strncpy()函数

    1. 函数声明原型:
     char *strncpy( char *strDest, const char *strSource, size_t count );
    
    1. 函数功能:
      将字符串src前n个字符拷贝到字符串dest。
    2. 函数实现:
    #include<stdio.h>
    #include<assert.h>
    #include<stdlib.h>
    
    char* my_strncpy(char* dest, const char* src, size_t count)
    {
    	assert(dest);
    	assert(src);
    	char* ptr = dest;
    	while (count-- && *src != '\0')
    	{
    		*ptr++ = *src++;
    	}
    	if (*src == '\0')
    		*ptr = '\0';
    	return dest;
    }
    int main()
    {
    	char s1[] = "abcd";
    	char s2[] = "efg";
    	printf("%s\n", my_strncpy(s1, s2, 2));
    	system("pause");
    	return 0;
    }
    

    strncat()函数

    1. 函数声明原型:
     char *strncat( char *strDest, const char *strSource, size_t count );
    
    1. 函数功能:
      将n个字符追加到字符串的结尾。
    2. 函数实现:
    #include<stdio.h>
    #include<stdlib.h>
    #include<assert.h>
    
    char* my_strncat(char* dest, const char* src, size_t count)
    {
    	assert(dest);
    	assert(src);
    	char* ptr = dest;
    	while (*ptr++ != '\0');
    	ptr--;
    	while (count-- && *src != '\0')
    	{
    		*ptr = *src;
    		ptr++;
    		src++;
    	}
    	*ptr = '\0';
    	return dest;
    		
    }
    int main()
    {
    	char s1[] = "abcd";
    	char s2[] = "efgh";
    	printf("%s\n", my_strncat(s1, s2, 5));
    	system("pause");
    	return 0;
    }
    

    strncmp()函数

    1. 函数声明原型:
     int strncmp( const char *string1, const char *string2, size_t count );
    
    1. 函数功能:
      字符串前n个字符比较。
    2. 函数实现:
    #include<stdio.h>
    #include<assert.h>
    #include<stdlib.h>
    
    int my_strncmp(const char* s1, const char* s2, size_t count)
    {
    	assert(s1);
    	assert(s2);
    	while ((count--) && (*s1 != '\0') && (*s2 != '\0'))
    	{
    		if (*s1 > *s2)
    			return 1;
    		if (*s1 < *s2)
    			return -1;
    		s1++; s2++;
    	}
    	if (*s1 != '\0')
    		return 1;
    	if (*s2 != '\0')
    		return -1;
    	return 0;
    }
    int main()
    {
    	char s1[] = "bcd";
    	char s2[] = "bcdd";
    	printf("%d\n", my_strncmp(s1, s2, 5));
    	system("pause");
    	return 0;
    }
    

    memcpy()函数

    1. 函数声明原型:
    void * memcpy ( void * destination, const void * source,size_t num);
    
    1. 函数功能:
      从source的位置开始向后复制num个字节的数据到destination的内存位置。
    2. 函数实现:
    #include<stdio.h>
    #include<assert.h>
    #include<stdlib.h>
    void* my_memcpy(void* dest, const void* src, size_t count)
    {
    	assert(dest);
    	assert(src);
    	char* d = (char*)dest;
    	char* s = (char*)src;
    	while (count--)
    	{
    		*d = *s;
    		d++;
    		s++;
    	}
    	return dest;
    }
    int main()
    {
    	char s1[] = "abcdedfg";
    	char s2[] = "def";
    	printf("%s\n",(char*)my_memcpy(s1,s2));
    	return 0;
    }
    

    memmove()函数

    1. 函数声明原型:
    void* memmove(void* destination,const void* soucre,size_t num);
    
    1. 函数功能:
      从source的位置开始向后复制num个字节的数据到destination的内存位置。
      和memcpy的区别就是memmove函数处理的源内存块和目标内存块是可以重叠的;

    2. 函数实现:

    #include<stdio.h>
    #include<assert.h>
    #include<stdlib.h>
    void* my_memmove(void* dest, const void* src, size_t count)
    {
    	assert(dest);
    	assert(src);
    	//(1)当源内存的首地址等于目标内存的首地址时,不进行任何拷贝
    	//(2)当源内存的首地址大于目标内存的首地址时,实行正向拷贝
    	//(3)当源内存的首地址小于目标内存的首地址时,实行反向拷贝
    	char* _dest = (char*)dest;
    	char* _src = (char*)src;
    	if ( _dest > _src) // 从高地址到低地址拷贝
    	{
    		while (count--)
    		{
    			*(_dest + count) = *(_src + count);
    		}
    	}
    	else //从低地址到高地址拷贝
    	{
    		while (count--)
    		{
    			*_dest = *_src;
    			_dest++;
    			_src++;
    		}
    	}
    	return dest;
    }
    int main()
    {
    	char s1[] = "abcdedfg";
    	char s2[] = "def";
    	printf("%s\n",(char*)my_memmove(s1,s2));
    	return 0;
    }
    

    assert()函数用法

    转载assert()函数用法总结

    希望博主的这篇文章可以帮到你,,加油!!!

    展开全文
  • C语言常见字符串面试题

    千次阅读 2016-03-30 10:40:49
    原文见链接C语言常见字符串面试题 原文见链接字符串面试题(一)字符串逆序 原文见链接字符串类习题、面试题详解(第一篇)
    展开全文
  • golang常见字符串拼接通用处理方式

    千次阅读 2019-01-29 19:37:55
    golang常见字符串拼接处理方式1、参数名ASCII码从小到大排序2.按照特定的参数顺序拼接 我们在日常开发中,尤其是对接第三方登录、支付、分享等功能时, 时常需要对自己或接收到的数据进行一定的排序拼接后, 然后...

    前言

    我们在日常开发中,尤其是对接第三方登录、支付、分享等功能时,时常需要对自己或接收到的数据进行一定的排序拼接后, 然后进行或加密或校验的处理,虽然写死顺序可以解决问题,但代码缺少了灵活性。

    本文从通用性角度,以golang语言来处理一般情况下的字符串拼接问题。

    目前已开发成专门的拼接工具go-join,欢迎使用并提出意见。

    更多内容分享,欢迎关注公众号:Go开发笔记

    拼接处理

    目前经常遇到的排序方式主要有以下两种:

    1、参数名ASCII码从小到大排序

    以下是微信开发者平台的签名要求:

    签名生成的通用步骤如下:
    第一步,设所有发送或者接收到的数据为集合M,将集合M内非空参数值的参数按照参数名ASCII码从小到大排序(字典序),使用URL键值对的格式(即key1=value1&key2=value2…)拼接成字符串stringA。
    特别注意以下重要规则:
    ◆ 参数名ASCII码从小到大排序(字典序);
    ◆ 如果参数的值为空不参与签名;
    ◆ 参数名区分大小写;
    ◆ 验证调用返回或微信主动通知签名时,传送的sign参数不参与签名,将生成的签名与该sign值作校验。
    ◆ 微信接口可能增加字段,验证签名时必须支持增加的扩展字段
    
    //JoinStringsInASCII 按照规则,参数名ASCII码从小到大排序后拼接
    //data 待拼接的数据
    //sep 连接符
    //onlyValues 是否只包含参数值,true则不包含参数名,否则参数名和参数值均有
    //includeEmpty 是否包含空值,true则包含空值,否则不包含,注意此参数不影响参数名的存在
    //exceptKeys 被排除的参数名,不参与排序及拼接
    func JoinStringsInASCII(data map[string]string, sep string, onlyValues, includeEmpty bool, exceptKeys ...string) string {
    	var list []string
    	var keyList []string
    	m := make(map[string]int)
    	if len(exceptKeys) > 0 {
    		for _, except := range exceptKeys {
    			m[except] = 1
    		}
    	}
    	for k := range data {
    		if _, ok := m[k]; ok {
    			continue
    		}
    		value := data[k]
    		if !includeEmpty && value == "" {
    			continue
    		}
    		if onlyValues {
    			keyList = append(keyList, k)
    		} else {
    			list = append(list, fmt.Sprintf("%s=%s", k, value))
    		}
    	}
    	if onlyValues {
    		sort.Strings(keyList)
    		for _,v := range keyList {
    			list = append(list,data[v])
    		}
    	}else {
    		sort.Strings(list)
    	}
    	return strings.Join(list, sep)
    }
    

    示例:

    	data := make(map[string]string)
    	data["appid"] = "wx_1234535"
    	data["body"] = "test data"
    	data["mch_id"] = "572836589"
    	data["notify_url"] = "http://www.baidu.com"
    	data["trade_type"] = "MWEB"
    	data["spbill_create_ip"] = "192.169.0.1"
    	data["total_fee"] = "100"
    	data["out_trade_no"] = "2745890486870"
    	data["nonce_str"] = "kdjskgjokghdk"
    	data["sign"] = "signData"
    	log.Println("str :", JoinStringsInASCII(data, "&", false, false, "sign"))
    	log.Println("str2 :", JoinStringsInASCII(data, "&", true, false, "sign"))
    

    示例结果:

    str : appid=wx_1234535&body=test data&mch_id=572836589&nonce_str=kdjskgjokghdk&notify_url=http://www.baidu.com&out_trade_no=2745890486870&spbill_create_ip=192.169.0.1&total_fee=100&trade_type=MWEB
    str2 : wx_1234535&test data&572836589&kdjskgjokghdk&http://www.baidu.com&2745890486870&192.169.0.1&100&MWEB
    

    2.按照特定的参数顺序拼接

    //JoinStringsInOrder 数名按固定顺序排列后拼接
    //data 待拼接的数据
    //sep 连接符
    //onlyValues 是否只包含参数值,true则不包含参数名,否则参数名和参数值均有
    //orders 按照顺序的参数名,没有的不参与拼接
    func JoinStringsInOrder(data map[string]string, sep string,onlyValues bool, orders ...string) string {
    	var list []string
    	for _, key := range orders {
    		if _,ok := data[key];!ok {
    			continue
    		}
    		if onlyValues {
    			list = append(list, data[key])
    		}else {
    			list = append(list, fmt.Sprintf("%s=%s", key, data[key]))
    		}
    	}
    	return strings.Join(list, sep)
    }
    

    示例:

    log.Println("str3 :", JoinStringsInOrder(data, "&", false, "appid","body","mch_id","notify_url"))
    log.Println("str4 :", JoinStringsInOrder(data, "&", true, "appid","body","mch_id","notify_url"))
    

    示例结果:

    str3 : appid=wx_1234535&body=test data&mch_id=572836589&notify_url=http://www.baidu.com
    str4 : wx_1234535&test data&572836589&http://www.baidu.com
    
    展开全文
  • replace()方法,可以去除全部...strip()方法,去除字符串开头或者结尾的空格; rstrip()方法,去除字符串结尾的空格; lstrip()方法,去除字符串开头的空格; join()方法+split()方法,可以去除全部空格;  ...

    replace()方法,可以去除全部空格;

    strip()方法,去除字符串开头或者结尾的空格;

    rstrip()方法,去除字符串结尾的空格;

    lstrip()方法,去除字符串开头的空格;

    join()方法+split()方法,可以去除全部空格;

     

    展开全文
  • golang常见字符串操作函数

    万次阅读 2020-10-03 09:59:53
    字符串转换为int:strconv.Atoi() 字符串转化为float:strconv.ParseFloat() 字符串比较:strings.Compare() 字符串查找,包含:strings.Contains() 字符串查找位置:strings.Index() 统计子串出现的个数...
  • hive 常见字符串函数

    千次阅读 2019-07-01 10:58:10
    字符串函数在hive中经常使用,本篇博客将记录一些常用的字符串函数(持续更新) 1、字符串分割函数:split 语法: split(string str, string regex) 返回值: array 说明: 按照 pat 字符串分割str,会返回分割后的...
  • presto中常见字符串函数操作

    万次阅读 2020-09-05 23:58:13
    1、字符串截取substr presto是这样用的: substr(string,start,length)→ varchar 如:select substr('1599319787151',1,10) substr(string, start) → varchar 如:select substr('1599319787151',1) 而hive中:...
  • 常见字符串常量和表达式

    千次阅读 2017-09-25 10:48:45
    字符串
  • 1:strip()方法,去除字符串开头或者结尾的空格 a = " a b c " a.strip() ‘a b c’ 2:lstrip()方法,去除字符串开头的空格 a = " a b c " a.lstrip() 'a b c ’ 3:...
  • 常见字符串函数的实现

    千次阅读 2017-12-24 20:52:35
    strlen(),strcpy()int my_strlen(const char *str)//字符串长度 { assert(str != NULL); int len = 0; while (*str ++ != '\0') { ++ len; } return len; }char *my_strcpy
  • sql常见字符串查询语句

    千次阅读 2018-04-15 22:23:40
    beijingSELECT LEFT('beijing2008',7),RIGHT('beijing2008',4)# 字符串连接查询,与null连接都为null =&gt;aavvvbSELECT CONCAT('aa','vvvb')#位置插入查询 =&gt;beijmeng2008youSELECT INSERT('beijing2008...
  • C语言常见字符串函数实现

    千次阅读 2017-05-23 20:01:35
    // 返回值:返回子字符串string2在string1中的地址,如果没有找到返回NULL char *strstrTest( const char *str1, const char *str2) { char *pStr1 = ( char *)str1; char *pStr2 = ( char *)str2...
  • 字符串是一种常见的数据结构,对字符串的处理又可以十分灵活,所以在实际开发,尤其是非数值处理中,字符串的应用非常广泛。虽然很多字符串操作都封装在了函数库里,应用程序可以直接通过调用库函数来实现字符串处理...
  • 本文实例讲述了Python常见字符串操作函数。分享给大家供大家参考,具体如下: str.split(’ ') 1.按某一个字符分割,如‘.’ >>> s = ('www.google.com') >>> print(s) www.google.com >>&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 642,450
精华内容 256,980
关键字:

常见字符串