常见字符串函数及其复写

最新推荐文章于 2021-12-22 00:57:32 发布
最新推荐文章于 2021-12-22 00:57:32 发布
阅读量1.2k 收藏 21
点赞数 19
分类专栏： c语言 文章标签： c语言 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55439426/article/details/120876452
版权

文章目录

前言：

博主实力有限 ，博文有什么错误，请你斧正，非常感谢！
编译器：VS2019
本文介绍C语言<string,h>中那些常用的函数,及其复写。
因为C语言只给出了，函数的作用，对函数实现并不关心，因此在VS2019下某些字符串函数的行为可能与其它编译器不同，但是效果是大同小异的。
复写strstr时，博主目前掌握了BF算法，对于KMP算法将会在后续独立出一篇博客。

长度不受限制的函数

strlen

size_t strlen(const char string);*

  • 返回字符串中的字符数，不包括终止空字符（‘\0’）。

注意：strlen在计算字符数时，只要碰到‘\0’，就结束计算.这就可以认为当没碰到‘\0’,就不停止计算。因此说长度不受限制

​ image-20211019142905718

  • 返回值：无符号整形，因此在赋值时，某些编译器可能会报警告

  • 参数是：常量字符指针。（不可修改指向的数据）

strlen复写(3种，指针，递归，循环)

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <assert.h>
//我的：循环，递归，指针
size_t my_strlen1(const char* string)//循环
{
	assert(string);//防止传入NULL指针

	size_t cnt = 0;
	while (*string++)
	{
		++cnt;
	}
	return cnt;
}
size_t my_strlen2(const char* string)//递归
{
	assert(string);
	return *string == '\0' ? 0 : 1 + my_strlen2(string + 1);
}
size_t my_strlen3(const char* string)//指针
{
	assert(string);

	const char* bigin = string;
	while (*string++)//注意这里当*string=='\0'时，string指向了'\0'后面的位置,因此返回时，要-1
	{

	}
	return (string - bigin-1);
}
int main()
{
	char arr[] = "hello";
	printf("%d\n", my_strlen1(arr));//循环
	printf("%d\n", my_strlen2(arr));//递归
	printf("%d\n", my_strlen3(arr));//指针



	return 0;
}

image-20211019150431695

strcpy

char * strcpy(char dest,const char src);

  • 将src指向的内容依次拷贝到 dest指向的内存,直到遇到str中的’\0‘，同时返回dest的首地址。如果没遇到‘\0’,也就是src不存在’\0‘,会访问非法内存，

  • 常量字符指针，不能更改str指向的内容。

strcpy复写

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <assert.h>
char* my_strcpy(char* dest, const char* src)
{

	assert(dest && src);//防止传入NULL指针
	char* ret=dest;
	while (*dest++=*src++)//当dest传入'\0',停止拷贝
	{
		;
	}
	return ret;
}
int main ()
{
	char arr[20]={ 0 };
	printf("%s\n", my_strcpy(arr, "helloword"));
	return 0;
}

image-20211019150536294

strcat

char * strcat(char * dest , const char src);**

  • 从dest的字符串结束标志’\0‘开始，将src中的内容追加到dest后面。直到遇到src的’\0‘.如果没遇到，会非法访问内存。因此长度不受限制,不安全

  • 追加字符串时不执行溢出检查。因此dest中 必须由程序执行者，预留足够空间

  • 返回 dest的首地址

strcat复写

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);//防止传入NULL指针
	char* ret = dest;
	while (*dest)//找dest的'\0'位置，不可while(*dest++),因为找到'\0'时，dest越界了
	{
		dest++;
	}

	while (*dest++ = *src++)
	{

	}

	return ret;

}
int main()
{
	char arr[20] = "hello";
	printf("%s\n", arr);

	my_strcat(arr, "word");
	printf("%s\n", arr);


	return 0;
}

image-20211019150314167

strcmp

int strcmp(const char str1, const char str2);**

  • 比较字符串看的是ASICC，不是长度

  • 比较 字符串str1与字符串str2是否相等.并返回一个比较值（比较字符串，只能用它。）

  • 比较规则：

    • 先比较 str1与str2指向字符的ASSICC值，如果不同(代表字符串不等)就返回 2者差值。一旦相等就继续比较，直到str1与str2 同时都是‘\0’,（代表字符串相等）返回0；

    ​

  • 返回值。
    <0 字符串1小于字符串2。
    0 字符串1与字符串2相同。
    >0 字符串1大于字符串2。

  • 在复写时，我发现vs2019返回的是三个确定的值。虽然符合返回值要求，但是不能代表全部。这只是 vs内置的结果。因此复写了2种strcmp

strcmp复写（2种，正常，vs特置）

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 

#include <assert.h>
//正常
int my_strcmp1(const char* string1, const char* string2)
{
	assert(string1 && string2);

	while (*string1 == *string2)
	{
		if (*string1 == '\0')//当*s1,*s2同时为'\0'时，才说明字符串相等，返回0
		{
			return 0;
		}
		++string1;
		++string2;//前置++比后置++快
	}

	return (*string1 - *string2);

}
// vs2019版
int my_strcmp2(const char* src, const char* dest)
{
	int ret = 0;
	assert(src);
	assert(dest);
	while (!(ret = *(unsigned char*)src - *(unsigned char*)dest) && *dest)
		//unsigned char* 是因为char是否为有符号，根据编译器，默认不同
		//妙！以ret接受差值，通过！非0的数都为真.
		  //同时&&&的使用，确保了相等的情况。
	{
		++src;
		++dest;
	
	}

	if (ret < 0)
	{
	
		ret = -1;
	}
	else if (ret > 0)
	{
		ret = 1;
	}
		return (ret);
}
int main ()
{
	
	char arr1[] = "helloword";
	char arr2[] = "hello";

	if (0 == my_strcmp1(arr1, arr2))
	{
		printf("相等\n");

	}
	else
	{
		printf("不相等\n");
	}
	if (0 == my_strcmp2(arr1, arr2))
	{
		printf("相等\n");

	}
	else
	{
		printf("不相等\n");
	}
	return 0;
}

image-20211019212500645

为什么说这些函数不受限制

strlen,strcpy…这些字符串函数，只是执行代码，不关心会发生什么。有可能会访问非法内存。不安全。因此后面介绍长度受限制安全的strcnpy，一定程度上安全，但是不绝对

长度受限制的字符串函数

strncpy

char strncpy(char Dest,const char* Src,size_t count);**

  • 将 src前 count个字符拷贝到dest。但是如果count超过了src的字符个数时，会赋值’\0‘,

  • dest 的空间仍是程序调用者，自己控制

strncpy复写

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <assert.h>

char* my_strncpy(char* dest, const char* src, size_t cnt)
{

	assert(dest && src);
	char* ret = dest;
	if (strlen(dest) < (cnt - 1))//strlen的原因(不计数'\0')，因此cnt-1
	{
		printf("拷贝数目大于源字符串字节数，此行为是未定义的\n");
		exit(1);
	}

	//开始拷贝
	// 	   下面这种方式虽然可行，但是在vs调试中，我发现strncpy在 多余时，仍会对dest赋值'\0'
	//while ((cnt-- > 0)&&(*dest++ = *src++))//'\0'数值为0.因为 &&先左后右的求值顺序特点,
	//	                                  //当cnt为0时，可能还未到达src的末尾，其会再赋值一次非'\0'
	//{
	//	;
	//}
	//开始拷贝
	while (cnt > 0)
	{

		if (*dest = *src)//当*src为'\0'时，src不再++；
		{
			if (*src != '\0')
			{
				++dest;
				++src;

			}
			else
			{
				++dest;
			}
		}
		--cnt;
	}
	return ret;
}
int main()
{
	char arr1[20] = "hello";
	printf("%s\n", strncpy(arr1, "word", 8));
	char arr2[20] = "hello";
	printf("%s\n", my_strncpy(arr2, "word00", 5));
	char arr3[] = "hello";
	printf("%s\n", my_strncpy(arr3, "word", 4));
	return 0;
}

image-20211019214757386

strncat

*char strncat(char Dest,const char Src,size_t count );

  • 如果count大于src的长度，就将src全部追加到dest，包括‘\0’。反之，追加src前 count的字符。并再追加一个‘\0’

strcat复写

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <assert.h>


char* my_stcncat(char* dest, const char* src, size_t cnt)
{
	
	assert(dest && src);
	char* ret = dest;
	while (*dest)//定位源字符串的'\0'指针
	{
		dest++;

	}

	if (cnt > strlen(src))//当cnt大的时侯，就是完整拷贝。
	{
	
		while (*dest++=*src++)
		{
			;

		}

	}
	else {

		while ((cnt-->0)&&(*dest++=*src++))
		{
			;
		}
		*dest = '\0';//因为cnt小的原因，根据要求，追加完后，需要再追加一个'\0'
	}
	return ret;


}
int main()
{
	char arr1[20] = "helloxx\0xxxxxxxxxx";
	char arr2[20] = "helloxx\0xxxxxxxxxx";

	printf("%s\n", my_stcncat(arr1, "word", 3));
	printf("%s\n", strncat(arr2, "word", 3));

	return 0;
}

image-20211019222600438

strncmp

int strncmp( const char* str1, const*char str2,size_t cnt )

  • 当 cnt 大于 str1与str2 中长度最大的时，效果与 strcmp相同。反之 比较 长度最大的前cnt为。
  • 比较规则同strcmp
  • 注意复写时，我是以vs2019 为结论编写程序，返回值不是一个定值。

strncmp复写

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <assert.h>

int my_strncmp(const char* str1, const char* str2, size_t cnt)
{
	assert(str1 && str2);
	int ret = 0;
	while (!(ret=(*str1-*str2))&&(*str1)&&(*str2)&&(cnt>0))//只要当str1,str2其中为'\0'，或者cnt为0就停止
	{
		--cnt;
		++str1;
		++str2;
	}
	if (ret == 0)
	{
		return 0;
	}else if(ret>0)
	{
		return 1;
	}
	else
	{
		return -1;
	}
	
}
int main ()
{
	char* arr1 = "hello";

	char* arr2 = "hello";
	
	printf("%d\n", strncmp(arr1, arr2, 20));
	printf("%d\n", my_strncmp(arr1, arr2, 20));

	return 0;
}

image-20211019225750664

内存操作函数

memcpy,memmove（内存拷贝）

void * memcpy(void dest,const void src, size_t count )**

**void *memmove(void dest,const void src,size_t count);

  • 这2个函数都是内存拷贝函数，效果一样。区别在于 memcpy只管拷贝（不考虑重叠拷贝），而memmove

    在拷贝时会注意重叠拷贝的问题。因此称memcpy是半拷 贝，而memmove是全拷贝。

  • 注意VS2019中的memcpy，memmove都是全拷贝。

  • 因此在复写时，我选择了复写一个memmove

memmove复写

image-20211020152530870

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <assert.h>


void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);//断言，防止NULL指针

	if (dest <= src)//dest在前，从前往后拷贝
	{
		for (size_t i = 0; i < count; ++i)
		{
			*((char*)dest+i) =*((char*)src+i);
		}
	
	
	}
	else {

		for (size_t i = count-1; i>0; --i)//dest在后，从后往前拷贝,注意因为无符号的问题，
			                              //要考虑溢出问题。防止死循环。因此i=0的位置单独赋值
		{
			*((char*)dest + i) = *((char*)src + i);
		}
		*(char*)dest = *(char*)src;
	}

	return dest;

}
int main ()
{
	char arr1[20] = "hellowordxxxxx";
	char arr2[20] = "hellowordxxxxx";

	printf("%s\n", arr1);
	my_memmove(arr1, arr1 + 3, 5);//dest在前
	printf("%s\n", arr1);
	
	printf("%s\n", arr2);
	my_memmove(arr2+3, arr2 , 5);//dest在后
	printf("%s\n", arr2);
	return 0;
}

memcmp（内存比较）

**int memcmp(const void buf1,const void buf2，size_t count);

  • 比较内存中的元素，与strcmp道理相同。只是以内存角度比较字节。

  • memcmp是将内存中的补码看成无符号型，。

image-20211020162606752

memcmp复写

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <assert.h>


int my_memcmp(const void* buf1, const void* buf2, size_t count)
{

	assert(buf1 && buf2);
	int ret = 0;
	//注意一定是无符号的char*,因为memcmp看的是无符号
	while (count&&(!(ret=*(unsigned char*)buf1 -*(unsigned char*)buf2))) //因为&&的原因，count要在前，提前结束，一旦比较元素不相等就停止。
	{                                                //相等就继续比较.因为不同于字符串，直到count为0.
		buf1 = ( unsigned char*)buf1 + 1;                       // 防止比较多了。
		buf2 = ( unsigned char*)buf2 + 1;                   
		--count;
	}
	if (ret > 0)
	{
	
		return 1;

	}
	else if(ret<0)
	{
		return -1;
	
	}
	else
	{
	
		return 0;
	}



}
int main ()
{
	int a = 10001;
	int b = 10;
	
	
	printf("%d\n", my_memcmp(&a, &b, 4));

	printf("%d\n", memcmp(&a, &b, 4));
	
	return 0;
}

image-20211020162859221

memset（内存赋值）

void memset(void*dest,int c,size_t count);*

  • 将缓冲区(内存)设置为指定的字符c。
  • 缓冲区的大小由调用者设置，要合适。

memset复写

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <assert.h>
void* my_memset(void* dest, int c, size_t count)
{
	assert(dest);
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = c;
		dest = (char*)dest + 1;
	}

	return ret;
}
int main ()
{
	char arr[20] = "xxxxxword";
	printf("%s\n", arr);

	my_memset(arr, 'h', 5);
	printf("%s\n", arr);
	
	
	return 0;
}

image-20211020163920111

字符串查找函数

strstr

char strstr(const char*str1,const char * str2);*

  • 在str1中搜索str2.要求str1于str2都是NULL结尾的字符串，否则行为未定义

  • 返回一个指针，指向字符串 中首次出现的str2，如果字符串中没有出现str2，则返回NULL。如果str2指向长度为零的字符串，则函数返回字符串。

  • 使用的是BF（暴力查找法）复写。KMP会在后续单独一篇博客

复写strstr

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <assert.h>
char* my_strstr(const char* string, const char* strCharSet)
{
	assert(string && strCharSet);
	if (*strCharSet == '\0')//传入空的时候，就返回string
	{

		return (char*)string;//返回值的类型是 char*，但是string是const char*，因此需要强制为char*
	}
	while (*string)
	{
		//进行匹配活动
		const char* s1 = string;
		const char* s2 = strCharSet;
		while ((*s2 != '\0') && (*s1 != '\0') && (*s1 == *s2))//&&的妙用。一旦一个假就停止遍历。
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')//我们关注的是：是否找到，必须先判断s2的情况，一旦成立就找到了。其它情况不需要考虑。
		{

			return (char*)string;
		}

		if (*s1 == '\0')//当*s1为空时就没有必要再次循环，后面不会出现匹配的情况。
						//但是当字符数组中没有一个匹配的字符时，*string为'\0'的特殊情况
		{

			return NULL;
		}

		string++;
	}
	return NULL;//当
}
int main()
{
	char arr[] = "abcdef";
	if (my_strstr(arr, "def")!=NULL)
	{
		printf("找到了\n");
	}
	else
	{
		printf("找不到了\n");

	}
	return 0;
}

image-20211020170233962

切分字符串

strtok

char strtok(char str,const char sep)*

  • sep是分隔符的集合

  • str指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记，标记是一个非包含sep的字符串。

  • 如果传入的参数str不为NULL，那么strtok会返回第一个标记的首地址，并将分隔符置为‘\0’，同时strtok会记住这个分隔符的位置。如果传入的参数为NULL，strtok会从记住的位置开始分割字符串。

  • 也就是说我们想将一个字符彻底切分完，在第二次调用时要传入NULL。

  • 如果字符串中不存在更多的标记，则返回 NULL 指针

  • 下面距离说明：

image-20211020202141568

strtok复写：

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <assert.h>

int isfind( char* str, const char* sep)//BF查找。二分需要排序。另外esp中字符少
{                                      
	for (size_t i = 0; i < strlen(sep); ++i)
	{
		if (*str == sep[i])
		{
			return 1;
		}
	}
	return 0;
}
char* my_strtok(char* str, const char* sep)
{
	 char* ret = NULL;
	 static char* sp = NULL;
	 int Flage = 0;//帮助记录标记的起始地址
	if (str != NULL)//传入非NULL指针，就找第一个标记
	{
		
		for (size_t i = 0; i < strlen(str); ++i)
		{
			if ((isfind(str + i, sep) == 1)&&(Flage==1))//只有当记录了标记起始地址，才返回值。
			{
				sp = str + i+1;//+1,是为了方便查找.
				*(str + i) = '\0';
				return ret;
			}
			else if((isfind(str + i, sep)==0)&&(Flage==0))
			{
				ret = str + i;
				Flage = 1;//一旦Flage为1后，就不需要担心再次对ret赋值。
			
			}

		}
		return NULL;//没找到标记就返回NULL
	}
	else if(str==NULL&&sp!=NULL)
	{
		char* s = sp;
		while (*s!='\0')
		{

			if (isfind(s, sep) == 1&&Flage==1)
			{
				
				*s= '\0';
				sp = s + 1;
				return ret;
			}
			else if(isfind(s, sep) == 0 && Flage == 0)
			{ 
				ret = s;
				Flage = 1;
			}
			s++;
		}
	}
	sp = NULL;//当遇到'\0'时，需要返回这之前的标记地址。但是需要将记住的静态指针置为NULL.
	          // 因为最终需要返回一个NULL指针结束main的循环。
	return ret;
}
int main ()
{
	char arr[] = "- This, a sample string.";
	char* p = NULL;
	for (p = my_strtok(arr, "- ,"); p != NULL; p = my_strtok(NULL, "- ,"))
	{
		printf("%s\n", p);
	
	}

	return 0;
}

image-20211020214318375

错误信息报告

strerror,perror

char * strerror(int errnum);

*void*perror(const char string);

  • 编译器会将程序中的出现所有错误（如少分号，少{}等）对应一个码，称谓错误码。每个错误码对应一个错误信息字符串。而错误码存储在errno中（< errno,h >）

image-20211020215258086

  • strerror会返回错误码对应字符串的首地址。不会主动打印错误信息，因此如果需要打印错误信息，需要printf函数

  • perror不仅·可以自动打印错误信息，还可以人为的添加一些信息，与错误信息组成新的字符串。

image-20211020220656077

小结

  • 函数的复写过程，必须考虑到很多情况，提高函数的鲁棒性。可能BF算法笨（我就是。。。。。），但是算法都是一步一步优化的。
  • 关于字符串函数就介绍到这了。如果想了解其它字符串函数，可以去网站：https://en.cppreference.com/w/
New Young
关注
  • 19
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
操作字符串的函数
Jason's Word
06-02 564
<br />  自己写的一个操作字符串的函数<br /> <br />   /// <summary> /// 作者：it小金 /// 说明：在字符串中找出数字部分 /// </summary> /// <param name="str">待检查的字符串</param> /// <returns></returns> public static string StrFindNum(string str
Dart-操作符复写
solo_jm的博客
11-15 214
定义格式 操作符要在类中定义，格式为： 返回类型 operator 操作符（参数列表）{ 实现体； return 返回值 } 实例 main() { Person a = new Person(18); Person b = new Person(15); print(a > b); //报错，无法判断 } class Person { int age; Pe...
重写（复写）和重载的区别
qq_31978495的博客
12-28 4717
重写（复写）是子类的方法覆盖父类的方法，要求方法名和参数相同，访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private） 重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。 重载是在同一个类中有两个或两个以上的方法，拥有相同的方法名，但是参数不同（参数个数、次序、类型不同），对返回值没有要求，可以相同
菜鸟写代码--复写0，其余元素平移--03
yangqiqi1997的博客
02-09 210
题目： 给你一个长度固定的整数数组 arr，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。 注意：请不要在超过该数组长度的位置写入元素。 要求：请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。 public class pingyi { public static void main(String[] args) { int arr[]= {1,0,2,3,0,4...
openpose代码解析（1）全网最详细的 openpose 代码解析，手把手教你一步步完成代码复写
qq_42902997的博客
12-22 6809
文章目录训练使用的数据查看 h5 文件中包含的部分通过 gen 方法处理数据随机选择一个 datum 中的 key 进行查看用这个 key 得到相关的所有数据 entry从 meta 中得到 joints 的数据信息将 entry 中原本的 coco joints （17个点）转换为 global joints（18个点）: RmpeCocoConfig.convert()得到 neck 和 左右肩膀的标号确定两个肩膀都是存在标定的result[ [True], neckG, 0:2]最后得到 resul
Java4Android 20_函数的复写
09-07
在Java编程语言中，函数的复写（Overriding）是一个重要的概念，特别是在开发面向对象的程序时。函数的复写允许子类重定义父类中已存在的方法，以实现特定的功能或者提供更具体的实现。这一特性使得代码更具扩展性和...
day10-复写str方法
02-28
day10-复写str方法
Android开发笔记之:复写按钮方法
09-05
其次，`onBackPressed()`方法是处理设备返回键的回调函数。默认情况下，它会关闭当前活动并返回上一个活动。然而，开发者可以通过复写这个方法来实现自定义的返回行为，例如弹出对话框询问用户是否确认退出，或者...
行业文档-设计装置-本色力敏复写纸及其生产工艺.zip
08-20
《本色力敏复写纸及其生产工艺》是一个深入探讨造纸技术与材料科学的行业文档，主要聚焦于一种特殊类型的纸张——本色力敏复写纸。这种纸张的生产和应用在现代商业、办公以及教育等领域具有广泛的重要性。在本文档中...
行业分类-设备装置-无碳复写纸用微胶囊及其制备方法、无碳复写纸及其涂料.zip
09-10
无碳复写纸是一种在没有碳粉的情况下，能够实现多联单据复制的技术，它广泛应用于办公、财务、邮政等领域。这种技术的核心在于微胶囊，它们含有显色剂和发色剂，通过压力作用使胶囊破裂，使得显色剂与发色剂结合，...
android复写代码,Android开发笔记之:返回键的复写onBackPressed()介绍
weixin_36269709的博客
05-26 295
在android开发中，当不满足触发条件就按返回键的时候，就要对此进行检测。尤其是当前Activity需要往前一个Activity传送消息时。即Activity1跳转到Activity3如果采用的是startActivityForResult这种方式，如果不重写返回键，程序不知道要返回给Activity1什么内容就会报错。因此，必须对Activity3的返回按键重写，这里让他传一个“ERROR”信...
十年程序员的告诫：千万不要重写代码！
热门推荐
CSDN资讯
02-27 1万+
对重写代码说不。作者 |Roman Luzgin译者 | 苏本如责编 |屠敏出品 |CSDN（ID：CSDNNews）以下为译文：重写代码消耗了12个月！我们从头开...
常见字符串函数的实现
wtzdedaima的博客
12-24 4726
strlen(),strcpy()int my_strlen(const char *str)//字符串长度 { assert(str != NULL); int len = 0; while (*str ++ != '\0') { ++ len; } return len; }char *my_strcpy
JAVA基础（一）重载和复写
九天烽火
01-21 4176
最近开始研究Android的设计模式，主要是感觉在已经能完成大部分功能型代码后，感觉到了框架结构的重要性，可是在研究过程中又发现了另一个问题。自己的JAVA基础似乎并不是太好，很多东西都停留在表面，这样就致使自己研究设计模式遇到了很大问题。就像地基没有打好，往上修了几层房子，然而再想往上修就修不上去了。于是回头从JAVA基础开始，将基础重新巩固学习一遍，并将笔记记录在此。 JAVA中重载和复写有什
重写代码的实战经验和那些坑
博客
05-10 1103
原文： When to Rewrite from Scratch - Autopsy of a Failed Software 作者： Umer Mansoor 翻译： 孙薇 责编： 钱曙光，关注架构和算法领域，寻求报道或者投稿请发邮件qianshg@csdn.net，另有「CSDN 高级架构师群」，内有诸多知名互联网公司的大牛架构师，欢迎架构师加微信qshuguang20...
Java 复写方法的调用顺序
知之为知之，不知为不知，是知也
05-24 892
接触新项目，今天看代码的时候，发现一段代码的调用顺序和打印的log有点冲突，且看Demo代码类Animal.class：public class Animal extends Alive { public String name; public void setName(String str){ name = str; } public Stri...
代码重复规则
可乐的专栏
03-17 1412
李炜 北京杰合伟业软件公司产品技术部经理2001 年 7 月本文来自《IBM DeveloperWorks》代码复用是绝大多数程序员所期望的，也是OO的目标之一。总结我多年的编码经验，为了使代码能够最大程度上复用，应该特别注意以下几个方面。1、 对接口编程 "对接口编程"是面向对象设计（OOD）的第一个基本原则。它的含义是：使用接口和同类型的组件通讯，即，对于所有完成相同功能的组件，应该抽
复写icon.Rescale（）函数
最新发布
04-23
在进行函数复写时，需要先确定函数的输入参数和输出结果，然后根据实际需求修改函数的内部实现。以下是一个可能的实现方式： ```python def Rescale(self, new_width, new_height): # 获取原始图标的尺寸信息 old...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值