当前位置:网站首页>C | utilisation de la fonction de caractère commune et de sa mise en œuvre analogique (1)

C | utilisation de la fonction de caractère commune et de sa mise en œuvre analogique (1)

2021-10-14 06:45:46 Ersansui

Préface

Les gars,InCDans la langue,String(Tableau de caractères)Est un type de données que nous utilisons souvent.

En écrivant le Code,Il est inévitable que nous fassions quelque chose à ce sujet,C'est le moment d'utiliser notre fonction de caractère.

Aujourd'hui, apprenons quelques fonctions de caractères communes~

En même temps,Pour mieux comprendre ces fonctions,Je vais vous montrer comment simuler ces fonctions~

Insérer la description de l'image ici

strlen

size_t strlen ( const char * str );

Voici la liste des paramètres formels et le type de retour de cette fonction,

Cette fonction est utilisée pour calculer la longueur de la chaîne.

En utilisant cette fonction,La première adresse de la chaîne requise doit être passée,Et recevoir la valeur de retour avec un entier non signé.

Attention!

La chaîne sera ‘\0’ Comme signe de fin,strlenLa valeur de retour de la fonction est dans la chaîne ‘\0’ Nombre de caractères précédents(Ne contient pas ‘\0’ ).

Donc la chaîne que nous passons à cette fonction doit contenir‘\0’.

Démonstration de code:

#include <stdio.h>
int main()
{
    
	const char* str1 = "abcdef";
	const char* str2 = "bbb";
	if (strlen(str2) - strlen(str1) > 0)
	{
    
		printf("str2>str1\n");
	}
	else
	{
    
		printf("srt1>str2\n");
	}
	return 0;
}

Le résultat du code ci - dessus est

srt1>str2

C'est comme ça que cette fonction est utilisée , Regardons l'implémentation analogique de cette fonction .

Il y a trois façons d'implémenter cette fonction ~

Les codes sont les suivants::

Méthode 1

Méthode d'utilisation des compteurs

//Attention!:strlen La valeur de retour de estsize_t, Type non signé 
// 
// Concevoir la fonction en fonction de ce type de retour et des paramètres formels 
size_t my_strlen(char* arr) {
    
 
 	// Déterminer si le pointeur entrant est vide 
	assert(arr);

	size_t count = 0;
	int i = 0;

	//La condition de jugement est:arr[i] L'élément dans n'est pas '\0'
	while (arr[i]) {
    
		count++;
		//i++ Laissez le pointeur pointer vers l'élément suivant 
		i++;
	}
	//Siarr[i]L'élément dans est'\0', Alors quittez la boucle ,Retourcount
	return count;
}

Méthode 2

En utilisant une méthode récursive

size_t my_strlen(char* arr) {
    

	// Déterminer si le pointeur entrant est vide 
	assert(arr);

	// Quand la récursion à ‘\0’Quand, Celui - ci ne compte pas ,Donc le retour est0
	if (*arr == '\0') {
    
		return 0;
	}
	//Le reste,Retour1+ Valeur de retour de l'élément pointé par le pointeur suivant 
	else {
    

		return 1+my_strlen(arr+1);
	}

}
size_t my_strlen(char* arr) {
    

 	// Déterminer si le pointeur entrant est vide 
	assert(arr);
 
	// Pour créer un pointeur de caractères temporaire pour enregistrer la position du pointeur 
	// Pour faciliter le déplacement du pointeur vers l'arrière 
	char* tmp = arr;

	//Quandtmp L'élément de n'est pas ‘\0’Continuez à tourner.,Sinon, quittez
	while (*tmp) {
    
		tmp++;
	}
	//Après la sortie,tmp-arr Représente le pointeur à la fin moins le pointeur au début , Représente le nombre d'éléments qui diffèrent 
	return tmp - arr;

}

strcpy

char* strcpy(char * destination, const char * source );

Le but de cette fonction est de source Copie de la chaîne pointée vers destination Dans la chaîne pointée ,Etdestination Le contenu original de la chaîne pointée sera écrasé .

Attention!

sourceChaîne pointée, C'est - à - dire que la chaîne source doit ‘\0’ Fin.

L'espace cible doit être assez grand,Contenu qui peut contenir la chaîne source inférieure.Sinon, une erreur sera signalée.

L'espace cible doit être modifiable. C'est - à - dire que le pointeur de l'espace cible ne peut pas être constModification.

Démonstration de la méthode d'utilisation:

int main() {
    

	char arr1[] = "hello world";
	char arr2[] = "nihao!";

	char* tmp = strcpy(arr1, arr2);
	printf(tmp);

	return 0;
}

Le dernier résultat imprimé est :

nihao!

Le Code d'implémentation analogique est le suivant :

//Selonstrcpy Type de paramètre et type de retour pour la conception 
char* my_strcpy(char* dest, const char* source) {
    

	// Déterminez si les deux pointeurs entrants sont vides 
	assert(dest && source);
	
 // Créer un pointeur de caractères pour enregistrer la première adresse de l'espace cible , Pour un retour ultérieur 
	char* ret = dest;
	
	Quandsource Le contenu de n'est pas 0Quand, Continuer la copie ,Sinon, quittez
	while (*source != '\0') {
    

		*dest = *source;
		dest++;
		source++;

	}
	// N'oubliez pas à la fin dest A la fin de \0
	*dest = '\0';
	return ret;

}

On pourrait aussi optimiser

char* my_strcpy(char* dest, const char* source) {
    

	// Déterminer si les deux pointeurs sont vides 
	assert(dest && source);
	char* ret = dest;

	//Postposition++,Utiliser d'abord, puis auto - augmenter
	// Copie de la dernière lettre à destAprès,source Depuis l'augmentation, pointez vers \0
	//Et mettre\0Assigner une valeur àdest,En ce momentdestLa valeur de0,Cycle de sortie
	while (*dest++ = *source++) {
    
		;
	}

	return ret;
}

strcat

char * strcat ( char * destination, const char * source );

Cette fonction est une chaîne de caractères qui ajoute l'espace source à l'espace cible , Le contenu original de l'espace cible ne sera pas écrasé .

Attention!

La chaîne source doit être ‘\0’ Fin.

L'espace cible doit être assez grand,Contenu qui peut contenir la chaîne source inférieure.

L'espace cible doit être modifiable.

Utilisez la démonstration suivante :

int main() {
    

	char arr1[] = "hello world";
	char arr2[] = "nihao!";

	char* tmp = strcat(arr1, arr2);
	printf(tmp);

	return 0;
}

Les résultats sont les suivants:

hello worldnihao!

La simulation est réalisée comme suit :

//Selonstrcat Paramètres et types de retour pour la conception 
char* my_strcat(char* dest, const char* source) {
    

	// Déterminer si le pointeur est vide 
	assert(dest && source);

	// Créer un pointeur de caractères pour enregistrer la position de départ de l'espace cible ,Faciliter les retours ultérieurs
	char* ret = dest;

	//Pour fairedestPointage\0Emplacement
	while (*dest != '\0') {
    
		dest++;
	}

	 Lorsque l'élément courant de l'espace source n'est pas 0Heure,Ajouter
	while (*source != '\0') {
    
		*dest = *source;
		dest++;
		source++;
	}
	// Après avoir quitté la boucle, ajouter '\0'
	*dest = '\0';

	return ret;
}

La même chose., Le code ci - dessus peut encore être optimisé

char* my_strcat(char* dest, const char* source) {
    

	// Déterminer si le pointeur est vide 
	assert(dest && source);

	// Créer un pointeur de caractères pour enregistrer la position de départ de l'espace cible ,Faciliter les retours ultérieurs
	char* ret = dest;

	//Pour fairedestPointage\0Emplacement
	while (*dest) {
    
		dest++;
	}

	while (*dest++ = *source++) {
    
		;
	}

	return ret;
}

strcmp

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

Cette fonction est utilisée pour comparer si deux chaînes sont égales .

Attention!

La première chaîne est supérieure à la deuxième,Renvoie plus de0Nombre de.

La première chaîne est égale à la deuxième chaîne,Renvoie0.

La première chaîne est inférieure à la deuxième,Renvoie moins de0Nombre de.

Utilisez la démonstration suivante :

int main()
{
    
	//strcmp  C'est une comparaison de chaînes ,Comparer le contenu de la chaîne,Pas la longueur.

	char arr1[] = "abcq";
	char arr2[] = "abc";
	int ret = strcmp(arr1, arr2);

	if (ret == 0)
	{
    
		printf("=\n");
	}
	else if (ret < 0)
	{
    
		printf("<\n");
	}
	else
	{
    
		printf(">\n");
	}

	printf("%d\n", ret);

	return 0;
}

Les résultats sont les suivants:

>
1

La simulation est réalisée comme suit :

int my_strcmp(const char* str1, const char* str2) {
    

	// Déterminer si les deux pointeurs sont vides 
	assert(str1 && str2);

	while (*str1 && *str2) {
    

		if (*str1 > *str2)
			return 1;
		else if (*str1 < *str2)
			return -1;
		str1++;
		str2++;
	}

	// Il y a trois cas où la boucle supérieure saute :
	//str1Pour0Maisstr2Non.0
	//str1Non.0Maisstr2Pour0
	//str1Etstr2Tous.0

	if (*str1 == 0 && *str2 != 0) {
    

		return -1;
	}
	else if (*str1 != 0 && *str2 == 0) {
    

		return 1;
	}
	else
		return 0;

}

Voici une mise en œuvre plus simple , On peut continuer à optimiser ~

int my_strcmp(const char* s1, const char* s2)
{
    
	assert(s1 && s2);
	
	// Lorsque les deux pointeurs pointent vers des éléments égaux ,En boucle
	while (*s1 == *s2)
	{
    
		// Quand l'un d'eux est '\0'Heure, Prouver que les deux chaînes sont égales ,Retour direct0
		if (*s1 == '\0')
			return 0;
		// Deux pointeurs ++,Un peu en arrière,Continuer à comparer
		s1++;
		s2++;
	}
	
	// La valeur de retour peut être basée sur ASCII La valeur du Code correspond à 
	return *s1 - *s2;
}

Conclusion

C'est bon.,Voici le partage d'aujourd'hui~

Il y a aussi des fonctions de caractères qui n'ont pas pu être écrites , Alors mets - le dans le prochain numéro ,Attendez avec impatience.~

En raison de mes connaissances limitées , Il y aura inévitablement des erreurs et des lacunes , Et demandez à vos amis de souligner ~

Enfin,La création n'est pas facile,J'espère que les copains pourront se concentrer sur、- Oui.、Collection!

Votre soutien , C'est ma plus grande motivation ~!

Insérer la description de l'image ici

版权声明
本文为[Ersansui]所创,转载请带上原文链接,感谢
https://chowdera.com/2021/10/20211013211538458H.html

随机推荐