C fonctionne pour travailler avec des lignes. Travailler avec des rangées. Classe de cordes. Designers de classe. Attribuer (), Ajoutez (), Insérer (), Remplacer (), Effacement (), Rechercher (), RFind (), Comparer (), C_STR (). Exemples. Considérons un exemple d'annonce et de chaînes de sortie.

La chaîne est une séquence d'ASCII ou de caractères Unicode. Rangées en siComme dans la plupart des langages de programmation de haut niveau sont traités comme un type distinct inclus dans le type de langue de base. Étant donné que la langue de SI selon son origine est le langage de programmation linguistique, il n'y a pas de type de données de chaîne dedans et les tableaux de caractères conventionnels sont utilisés comme rangées.
Historiquement, deux représentations du format de la chaîne sont les suivantes:
1. format ANSI;
2. Rangements avec le zéro final (utilisé dans SI).

Le format ANSI établit que la première position de la chaîne est sa longueur, puis suivez les lignes elles-mêmes. Par exemple, la représentation de la ligne "ma chaîne!" Ce sera comme suit:
11 'M' 'O' 'I' '' 'C' 'T' 'R' 'O' 'K' 'A' 'A' '!'! ''
Dans les chaînes avec le zéro final, les symboles de ligne de signification sont indiqués à partir de la première position et la configuration de la chaîne est nulle. La représentation de la chaîne précédemment considérée dans ce format a la forme:
'M' 'O' 'I' '' 'C' 'T' 'R' 'O' 'K' 'A' 'A' '!' 0

Annonce de chaîne en Si

Les lignes sont implémentées par des tableaux de caractères. Par conséquent, l'annonce de la ligne ASCII a la syntaxe suivante:
Nom de caractère [longueur]; Un d rangées en si Il a la même syntaxe que l'annonce d'un tableau unidimensionnel symbolique. La longueur de la chaîne doit être une valeur entière (dans la norme C89 - constante, dans la norme C99 peut être une expression). La longueur de la chaîne est indiquée avec le même symbole pour stocker le zéro final, donc quantité maximale Il y a moins de caractères dans une chaîne par unité inférieure à sa longueur. Par exemple, une chaîne peut contenir un maximum de vingt caractères, s'il est déclaré comme suit:
Char Str; L'initialisation de la chaîne en Si est effectuée lors de ses déclarations utilisant la syntaxe suivante:
Char Str [longueur] \u003d littéral de chaîne; String Literal est une chaîne de caractères ASCII de prisonniers dans des citations doubles. Exemples de lignes ADS avec initialisation:
Char Str1 \u003d "Entrez la valeur:", str2 \u003d ""; Exemple:
const-un message \u003d "message d'erreur!";

Travailler avec des lignes en si

Étant donné que les lignes de la langue SI sont des matrices de caractères, vous pouvez contacter n'importe quel symbole de caractère par son index. Pour ce faire, utilisez la syntaxe de la circulation sur l'élément du tableau, de sorte que le premier caractère de la chaîne a une index de zéro. Par exemple, dans le fragment suivant du programme de la chaîne, le STR est remplacé par tous les caractères 'A' sur les personnages 'A' et inversement.
pour (int i \u003d 0; str [i]! \u003d 0; i ++)
{
si (str [i] \u003d\u003d 'a') str [i] \u003d 'a';
Sinon si (STR [i] \u003d\u003d 'A') STR [I] \u003d 'A';
}

Tableaux Rows en Si

L'annonce des lignes dans la langue Si est également possible. Pour cela, des tableaux de caractères bidimensionnels sont utilisés, qui a la syntaxe suivante:
Char [Quantité] [longueur]; La première taille de la matrice indique le nombre de lignes dans la matrice et la seconde est le maximum (en tenant compte de la nulture zéro) la longueur de chaque ligne. Par exemple, une déclaration de matrice de cinq lignes avec une longueur maximale de 30 caractères significatifs sera vue:
Char Strs; Lorsque vous déclarez des tableaux de lignes, vous pouvez initialiser:
Char Nom [Numéro] [longueur] \u003d
(chaîne littéral numéro 1, ... Numéro littéral à cordes n °Ne); Le nombre de littéraux de chaîne doit être inférieur ou égal au nombre de chaînes dans la matrice. Si le nombre de littéraux de chaîne est inférieur à la taille de la matrice, tous les autres éléments sont initialisés par des chaînes vides. La longueur de chaque littéral à chaîne doit être strictement inférieure à la longueur de la longueur de la chaîne (pour enregistrer le zéro terminateur).
Par example:
Char Jours \u003d (
"Janvier Février Mars Avril Mai",
"Juin", "juillet", "août", "septembre", "octobre",
"Novembre Décembre"
}; Lorsque déclare des tableaux de lignes avec initialisation, il est permis de ne pas spécifier le nombre de lignes de crochets. Dans ce cas, le nombre de lignes de la matrice sera déterminé automatiquement par le nombre d'alcooliques d'initialisation des chaînes.
Par exemple, un tableau de sept lignes:
Char Jours \u003d (
"Lundi Mardi Mercredi Jeudi",
"Vendredi Samedi Dimanche"
};

Fonctions pour travailler avec des rangées en Si

Toutes les caractéristiques de la bibliothèque conçues pour fonctionner avec des lignes peuvent être divisées en trois groupes:
1. Entrez et de sortie des chaînes;
2. Conversion en ligne;
3. Traitement en ligne.

Entrez et de sortie des rangées dans Si

Pour entrer et sortir les informations de chaîne, vous pouvez utiliser les fonctions d'entrée et de sortie formatées (Printf et Scanf). Pour ce faire, dans la chaîne de format lors de la saisie ou de la sortie d'une variable de chaîne, vous devez spécifier le spécificateur pour% s. Par exemple, l'entrée et la sortie suivante de la variable de chaîne examineront:
Char Str \u003d "";
Printf ("entrez une chaîne:");
Scanf ("% 30s", str);
Printf ("vous avez introduit:% s", str); L'inconvénient de la fonction Scanf lors de la saisie de données de chaîne est que les symboles des séparateurs de cette fonction sont les suivants:
1. Traduction du rang,
2. tabulation;
3. Espace.
Par conséquent, en utilisant cette fonctionnalité, il n'est pas possible d'entrer une chaîne contenant plusieurs mots séparés par des espaces ou des onglets. Par exemple, si dans le programme précédent, l'utilisateur entre dans la chaîne: "Message de plusieurs mots", seul "message" sera affiché à l'écran.
Pour entrer et sortir des chaînes de la bibliothèque STDIO.H, contient des fonctions spécialisées et met des fonctions.

La fonction Obtient est conçue pour entrer des chaînes et dispose du titre suivant:
Char * obtient (char * tampon);

La fonction METS est conçue pour produire des chaînes et possède le titre suivant:
Int met (Cons-Char * String); Le programme le plus simple: Entrer et les chaînes de sortie utilisant obtient et met des fonctions seront:
Char Str \u003d "";
Printf ("entrez une chaîne:"); Obtient (str);
Printf ("vous avez introduit:");
Met (str); Outre les fonctions d'entrée et de sortie des flux de la bibliothèque STDIO.H, il existe des fonctions d'entrée formatée et de sortie dans la chaîne. La fonction d'entrée formatée de la chaîne a le titre suivant:
INT SSCANF (Cons-Char * restreindre la mémoire tampon, Const Char * restreindre la chaîne, ...); Les fonctions de la sortie formatée dans la chaîne ont les en-têtes suivants:
Int sprintf (char * restreindre tampon,

Int SnPrintf (Char * restreindre tampon, taille_t maxsize,
Const char * restreindre le format, ...);

Conversion de ligne

En C pour convertir des lignes contenant des nombres de valeurs numériques dans la bibliothèque stdlib.h
L'ensemble de fonctions suivant est fourni:
Double atof (const char * string); // Convertir la chaîne en double type
Int Atoi (Cons-Char * String); // convertir la chaîne en type int
Long int atol (Cons-Char * String); // convertir la chaîne en int
Long long intoll int Atoll (Cons-Char * String); // transformation de ligne vers longtemps long La représentation correcte du nombre réel dans la chaîne de texte doit satisfaire au format:
[(+ | -)] [chiffres] [. chiffres] [(e | e) [(+ | -)]

Après les caractères E, E indique l'ordre du numéro. La représentation correcte d'un entier dans la ligne de texte doit satisfaire au format:
[(+ | -)] Numéros

En plus des fonctions ci-dessus dans la bibliothèque STDLIB.H, les fonctions de conversion de fonctions suivantes sont également disponibles en chiffres réels:
Float strtof (const Char * restreindre la chaîne, char * ** restreindre endptr);
Double strtod (Cons-Char * restreindre la chaîne, char * ** restreindre endptr);
Long double strtold (Cons-Char * restreindre la chaîne, char * ** restreindre Endptr);

Des fonctions similaires sont présentes et pour convertir des chaînes en valeurs entières:
Long Int Strtol (const Char * restreindre la chaîne

Non signé long strtoul (const char * restreindre la chaîne,
Char ** restreindre ENDPTR, INT BAS);
Long Long Int Strtoll (const Char * restreindre la chaîne,
Char ** restreindre ENDPTR, INT BAS);
Sans signé Long Long Strtour (Const Char * restreindre la chaîne, Char ** restreindre Endptr, int Bease);

Les fonctions de conversion inverse (valeurs numériques de la chaîne) dans la bibliothèque STDLIB.H sont présentes, mais elles ne sont pas réglementées par la norme et ne seront pas prises en compte. Pour convertir des valeurs numériques en chaîne la plus pratique pour utiliser les fonctions Sprintf et SNPRINTF.

Traitement de la rangée

La bibliothèque String.h contient des fonctions pour diverses actions au-dessus des lignes.
Fonction de calcul de longueur de chaîne:
Taille_t Strlen (Const Char * String); Exemple:
Char Str \u003d "1234";
INT N \u003d SHLEN (STR); // n \u003d\u003d 4 Fonctions de copie en ligne:
Char * Strcpy (Char * restreindre dst, const Char * restric src);
Char * Strncpy (Char * restreindre DST, Const Char * restreindre SRC, Taille_T Num); Fonctions de comparaison des lignes:
Int STRCMP (const char * string1, const char * string2);
Int STRNCMP (const char * string1, const char * string2, taille_t num); Fonctions Comparez les chaînes selon l'alphabet et retourner:
Valeur positive - si string1 est plus string2;
Valeur négative - si string1 est moins stress2;
Valeur zéro - si String1 coïncide avec String2;

Fonctions de combinaison de chaînes (concaténation):
char * strcat (char * restreindre dst, const char * restreindre src);
Char * STRNCAT (CHAR * restreindre DST, Const Char * restreindre SRC, Taille_T Num);

Fonctions de recherche de symboles dans la chaîne:
Char * Strchr (Cons-Char * String, Int C);
Char * strrchr (Cons-Char * String, int C);

Fonction de recherche de ligne dans la chaîne:
Char * Strstr (const Char * str, const char * substr);

Exemple:
Char Str \u003d "String pour la recherche";
Char * str1 \u003d strtstr (str, "for"); // str1 \u003d\u003d "chercher"

La fonction de recherche du premier symbole de la chaîne du jeu de caractères spécifié:
Taille_t strcspn (const Char * str, const Char * Charset);

Les fonctions de recherche du premier symbole de la chaîne de l'image n'appartiennent pas à l'ensemble de caractères spécifié:
Taille_t stress (const Char * str, const Char * Charset);

Les fonctionnalités de recherche du premier symbole de la chaîne de l'ensemble de caractères spécifié:
Char * Strpbrk (const Char * str, const Char * Charset);

La fonction de recherche du prochain littéral dans la ligne:
Char * String (Char * Restreindre la chaîne, Cons-Char * restreint Charset);

Travailler avec des rangées. Classe de cordes. Designers de classe. Attribuer (), Ajoutez (), Insérer (), Remplacer (), Effacement (), Rechercher (), RFind (), Comparer (), C_STR (). Exemples

1. Quelle est l'attribution de la classe de cordes dans les programmes C ++?

Classe de string conçue pour fonctionner avec des lignes Char *, qui sont une chaîne avec le zéro final. La classe de cordes a été entrée comme alternative pour travailler avec Char * Strings. Lignes qui sont complétées par le symbole ‘\0’ toujours appelé c-lignes. Depuis, la chaîne est une classe, vous pouvez déclarer des objets de cette classe.

2. Quels modules (bibliothèques) doivent être connectés pour utiliser les fonctions de la classe String dans MS Visual Studio C ++?

Pour utiliser les fonctionnalités de la classe String dans MS Visual Studio (C ++), vous devez connecter la bibliothèque. et espace de noms std.

#Inclure. Utilisation de Namespace STD;

3. Comment la déclaration d'une chaîne de type variable est-elle? Exemples

Une déclaration d'une chaîne de type variable est effectuée de la même manière qu'une variable ordinaire. Option d'annonce possible avec initialisation simultanée.

// type chaîne de chaîne S1; // variable avec le nom S1 Type String String s2 \u003d "Ceci est une variable de chaîne"; // une annonce d'initialisation // à l'aide d'une chaîne de type variable avec l'opérateur d'affectation S1 \u003d S2; // s1 \u003d "Ceci est une variable de chaîne" S2 \u003d "nouveau texte";

4. Quels avantages et inconvénients donnent l'utilisation de la classe de cordes en comparaison avec le char *?

La création d'un nouveau type de chaîne était due aux inconvénients du travail avec des chaînes de caractères, ce qui a démontré le type Char *. Par rapport à Char * Type String présente les principaux avantages suivants:

possibilité de traiter des chaînes avec des opérateurs C ++ standard ( = , + , = = , <> etc.). Comme vous le savez, lors de l'utilisation du type de caractère *, même les opérations les plus simples avec des rangées semblaient difficiles et demandaient à la rédaction d'un code de programme excessif;
fournir une meilleure fiabilité (sécurité) du code du programme. Par exemple, lors de la copie des chaînes, le type de chaîne fournit des actions appropriées pouvant survenir si la ligne source a plus grand qu'un récepteur de rangée;
fournir une chaîne en tant que type de données indépendant. Une chaîne de type annonce en tant que chaîne est une pour toutes les variables du programme qui fournit une cohérence dans les données.

Le principal inconvénient de la chaîne par rapport au type Char * est une vitesse de traitement de données lente. Cela est dû au fait que le type de chaîne est, en fait, la classe de conteneurs. Et le travail de classe nécessite une mise en œuvre supplémentaire du code de programme, qui, à son tour, prend trop de choses.

5. Quels opérateurs peuvent être utilisés avec des objets de classe de chaîne?

La classe String est pratique car elle vous permet de manipuler facilement des lignes à l'aide d'opérateurs standard (surchargés).

Vous pouvez utiliser les opérateurs suivants pour organiser des objets.

= - mission
+ - Concaentation (ramer)
+= - Cession avec la concaténation
== - égalité
!= - inégalité
< - moins
<= - Moins ou égal
> - Plus
>= - plus ou égal
- Indexation

Exemple, qui démontre l'utilisation des opérateurs ci-dessus

// Type de chaîne, Opérations de rangée Chaîne S1 \u003d "S-1"; String S2 \u003d "S-2"; String S3; Bool b; // opération "\u003d" (assignation de chaîne) S3 \u003d S1; // S3 \u003d "S-1" // opération "+" - concaténation des chaînes S3 \u003d S3 + S2; // S3 \u003d "S-1S-2" // opération "+ \u003d" - assignation avec la concaténation S3 \u003d "S-3"; S3 + \u003d "ABC"; // S3 \u003d "S-3ABC" // opération "\u003d\u003d" - comparaison des chaînes B \u003d S2 \u003d\u003d S1; // b \u003d faux b \u003d s2 \u003d\u003d "S-2"; // b \u003d vrai // Opération "! \u003d" - Comparaison des chaînes (non égales) S1 \u003d "S1"; S2 \u003d "S2"; B \u003d s1! \u003d S2; // b \u003d vrai // opérations "<" и ">"- Comparaison de la ligne S1 \u003d "ABCD"; S2 \u003d "de"; B \u003d S1\u003e S2; // b \u003d faux b \u003d s1< s2; // b = true // opérations "<=" и ">\u003d "- Comparaison des chaînes (moins ou égales, supérieure ou égale à) S1 \u003d "ABCD"; S2 \u003d "AB"; B \u003d S1\u003e \u003d S2; // b \u003d true b \u003d s1<= s2; // b = false b = s2 >\u003d "AB"; // b \u003d vrai // Opération - Indexation Char c; S1 \u003d "ABCD"; C \u003d s1; // c \u003d "c" c \u003d s1; // c \u003d "a"

6. Les concepteurs de chaîne de classe contiennent-ils?

Comme n'importe quelle classe, la classe de cordes comporte un certain nombre de concepteurs. Les principaux sont les suivants:

Chaîne (); Chaîne (const char * str); Chaîne (const string & str);

7. Exemples d'initialisation à l'aide de concepteurs

Vous trouverez ci-dessous des exemples d'initialisation des chaînes de type variables

String S1 ("Bonjour!"); String S2 \u003d "Bonjour!" ; // initialisation - concepteur de cordes (const Char * str) char * ps \u003d "bonjour"; String S3 (PS); // chaîne d'initialisation S4 (S3); // initialisation - Concepteur de chaîne (Const String & Str) String S5; // initialisation - concepteur de cordes ()

8. Affectation de chaînes. Assigner () fonction. Exemples

Pour attribuer une autre ligne, vous pouvez appliquer l'une des deux méthodes:

utilisez l'opérateur d'affectation ‘=’ ;
utilisez la fonction ASSIGN () de la classe de cordes.

La fonction ASSIGN () présente plusieurs implémentations surchargées.

La première option consiste à appeler la fonction sans paramètres.

String & Attribuer (void);

Dans ce cas, il y a une simple affectation d'une ligne une autre.

La deuxième option vous permet de copier le nombre spécifié de caractères de la chaîne:

String & Attribuer (const String & S, Taille_Type St, Taille_Type Num);

s est un objet à partir de laquelle la ligne source est prise;
sT - Index (position) dans la chaîne à partir de laquelle les symboles numb commencent;
num - le nombre de caractères à copier de la position ST;
type de taille - type ordinal Les données.

La troisième version de la fonction assign () est copiée sur l'objet appelant. Les premiers symboles de chaîne numérique S:

String & assign (const char * s, taille_type num);

s - une chaîne qui est complétée avec un symbole ‘\0’ ;
num - le nombre de caractères copiés sur l'objet appelant. Les premiers caractères numériques de la chaîne S sont copiés.

Vous trouverez ci-dessous un exemple avec différentes implémentations de la fonction ASSIGN ().

Exemple.

// attribution de chaînes, assignez () fonction String S1 \u003d "Site"; Chaîne S2; String S3; Char * PS \u003d "Site"; S3 \u003d S1; // S3 \u003d "Site" S2.Assign (S1); // S2 \u003d "Site" S2.Assign (S1, 0, 4); // s2 \u003d "meilleur" s2.Assign (PS, 8); // s2 \u003d "bestprog"

9. Combinez des lignes. Append () fonction. Exemple

Pour combiner des chaînes, la fonction ajoute () est utilisée. Pour ajouter des lignes, vous pouvez également utiliser l'opération ‘+’ , par exemple:

Chaîne S1; Chaîne S2; S1 \u003d "ABC"; S2 \u003d "def"; S1 \u003d S1 + S2; // s1 \u003d "abcdef"

Cependant, la fonction ajoute () est bien adaptée si vous devez ajouter une partie de la ligne.

La fonction dispose des options de mise en œuvre suivantes:

String & APPEND (const String & S, Taille_Type Démarrer); String & Ajoutez (Cons-Char * s, Taille_Type Num);

Dans le premier mode de réalisation, la fonction reçoit un lien vers l'objet minuscule. s. qui est ajouté à l'objet appelant. Dans le deuxième mode de réalisation, la fonction reçoit un pointeur à la chaîne Const Char *, qui est complétée avec le symbole '\\ 0'.

Exemple. Démonstration de la fonction de la fonction annexe ().

String S1 \u003d "ABCDEF"; S2 \u003d "1234567890"; Ajouter (S2, 3, 4); // S1 \u003d "ABCDEF4567" Char * PS \u003d "1234567890"; S1 \u003d "ABCDEF"; S1.append (PS, 3); // s1 \u003d "abcdef123"

10. Insertion de caractères dans la chaîne. Insérer () fonction. Exemple

Pour insérer une ligne à une position spécifiée d'une autre ligne, vous devez utiliser la fonction Insérer (), qui comporte plusieurs options de mise en œuvre.

La première option de la fonction vous permet d'insérer toute la ligne S dans une position spécifiée du début de la chaîne d'appel (objet appelant):

String & Insert (Taille_Type Démarrer, const String & S);

La deuxième option de la fonction vous permet d'insérer une pièce (paramètres instartiste, Num) Strings S à la position spécifiée du début de l'appelant:

String & Insert (Taille_type Démarrer, Const String & S, Taille_Type Instart, Taille_Type Num);

Dans les fonctions ci-dessus:

s est une chaîne insérée dans la chaîne d'appel;
démarrer - position dans la chaîne d'appel, à partir duquel l'insertion de la chaîne est effectuée;
instart est une position dans la ligne S, à partir de laquelle l'insertion a lieu;
nB est le nombre de caractères de la chaîne S qui sont insérés de la position de l'instart.

String S1 \u003d "ABCDEF"; Chaîne S2 \u003d "1234567890"; S1.insert (3, s2); // s1 \u003d "abc" + "1234567890" + "def" \u003d "abc1234567890def" S2.insert (2, S1, 1, 3); // s2 \u003d "12bcd34567890"

11. Remplacement des caractères dans la chaîne. Remplacer () fonction. Exemple

La fonction Remplacer () effectue le remplacement des caractères de la chaîne d'appel. La fonction dispose des options de mise en œuvre suivantes:

String & Remplacer (Taille_Type Démarrer, Taille_Type Num, const String & S); String & Remplacer (Taille_Type Démarrer, Taille_Type Num, const String & S, Taille_Type Régulum);

Dans le premier mode de réalisation, l'appelant est remplacé par une chaîne s. Il est possible de définir une position (démarrage) et le nombre de caractères (num) dans la chaîne d'appel qui doit être remplacé par une chaîne s.

La deuxième version de la fonction Remplacer () diffère du premier en ce qu'elle vous permet de remplacer la partie de chaîne d'appel uniquement de la ligne S. Dans ce cas, deux sont définis paramètres supplémentaires: Renplstarta Position et nombre de caractères dans une chaîne S qui forment une sous-chaîne qui remplace la chaîne d'appel.

Exemple. Démonstration de fonctionnement remplacer () fonction.

String S1 \u003d "ABCDEF"; Chaîne S2 \u003d "1234567890"; S2.replace (2, 4, s1); // s2 \u003d "12ABCDEF7890" S2 \u003d "1234567890"; S2.replace (3, 2, s1); // s2 \u003d "123ABCDEF67890" S2 \u003d "1234567890"; S2.replace (5, 1, s1); // s2 \u003d "12345ABCDEF7890" // remplaçant les caractères, remplacer la fonction () String S1 \u003d "ABCDEF"; Chaîne S2 \u003d "1234567890"; S2.replace (2, 4, s1); // s2 \u003d "12ABCDEF7890" S2 \u003d "1234567890"; S2.replace (3, 2, s1); // s2 \u003d "123ABCDEF67890" S2 \u003d "1234567890"; S2.replace (5, 1, s1); // s2 \u003d "12345ABCDEF7890" S2 \u003d "1234567890"; S2.replace (5, 1, s1, 2, 3); // s2 \u003d "12345CDE7890" S2 \u003d "1234567890"; S2.replace (4, 2, S1, 0, 4); // s2 \u003d "1234ABCD7890"

12. Suppression du nombre spécifié de caractères de la ligne. Effacer () fonction. Exemple

Pour supprimer les caractères de l'appelant, utilisez la fonction Erase ():

String & Erase (Index Taille_Type \u003d 0, Taille_Type Num \u003d NPOS);

index - Index (position), à partir duquel vous devez supprimer les caractères de l'appelant;
num - le nombre de caractères supprimés.

Exemple.

Chaîne S \u003d "01234567890"; S.erase (3, 5); // s \u003d "012890" S \u003d "01234567890"; S.erase (); // s \u003d ""

13. Symbole de recherche en ligne. Trouver () et rfind () fonctions. Exemples

Dans la classe String, la recherche d'une ligne dans la sous-chaîne peut être effectuée de deux manières différentes dans la direction de la recherche:

en affichage de la chaîne du début à la fin à l'aide de la fonction Rechercher ();
en affichant la ligne de la fin au début de la fonction RFind ().

La fonction de prototype Recherche () a la forme:

Taille_Type Trouver (const String & S, Taille_Type Démarrer \u003d 0) Const;

s - Substring, qui est recherché dans la ligne, ce qui provoque cette fonction. La fonction recherche la première entrée de la chaîne s. Si les sous-frères se trouvent dans la chaîne, ce qui a provoqué cette fonction, la position de la première entrée est renvoyée. Sinon retour -1;

Le prototype de la fonction RFind () a la forme:

Taille_type RFind (const String & S, Taille_Type Start \u003d Nos) const;

s - Substring, qui recherche dans l'appelant. La recherche de sous-chaîne dans la ligne est effectuée à partir de la fin au début. Si les sous-frères se trouvent dans la chaîne d'appel, la fonction renvoie la position de la première entrée. Sinon, la fonction renvoie -1;
les NPOS sont la position du dernier caractère de la chaîne d'appel;
démarrer est une position à partir de laquelle la recherche est effectuée.

Exemple 1. Le fragment de code qui démontre le résultat de la fonction trouve ()

// type de chaîne, trouver () Chaîne s1 \u003d "01234567890"; Chaîne S2 \u003d "345"; Chaîne S3 \u003d "ABCD"; int POS; Pos \u003d s1.find (S2); // pos \u003d 3 pos \u003d s1.find (S2, 1); // pos \u003d 3 pos \u003d s1.find ("jklmn", 0); // pos \u003d -1 pos \u003d s1.find (S3); // pos \u003d -1 pos \u003d s2.find (S1); // pos \u003d -1

Exemple 2. Démonstration de la fonction RFind ().

// Type de chaîne, Trouver () et RFind () Chaîne S1 \u003d "01234567890"; Chaîne S2 \u003d "345"; Chaîne S3 \u003d "ABCD"; String S4 \u003d "ABCD --- ABCD"; int POS; Pos \u003d s1.rfind (S2); // pos \u003d 3 pos \u003d s1.rfind (S2, 12); // pos \u003d 3 pos \u003d s1.rfind (S2, 3); // pos \u003d 3 pos \u003d s1.rfind (S2, 2); // pos \u003d -1 pos \u003d s2.rfind (S1); // pos \u003d -1 pos \u003d s1.rfind (S3, 0); // pos \u003d -1 // Différence entre Trouver () et RFind () Fonctions Pos \u003d s4.rfind (S3); // pos \u003d 7 pos \u003d s4.find (S3); // pos \u003d 0

14. Comparaison des parties de lignes. Comparer () fonction. Exemple

Puisque le type de chaîne est de classe, puis comparer deux lignes les uns avec les autres, vous pouvez utiliser l'opération ‘= =’ . Si deux lignes sont identiques, le résultat de la comparaison sera vrai. Sinon, le résultat de la comparaison sera faux.

Mais si vous devez comparer une partie d'une ligne de l'autre, la fonction Comparer () est fournie pour cela.

Prototype Comparer () Fonction:

INT Comparer (Taille_type Démarrer, Taille_Type Num, const String & S) Const;

s est une chaîne qui est comparée à la chaîne d'appel;
démarrage - position (index) dans la ligne S, à partir de laquelle les symboles de la chaîne de caractères commencent à comparer;
nUM est le nombre de caractères dans une chaîne S, qui sont comparés à la chaîne d'appel.

La fonction fonctionne comme suit. Si la chaîne d'appel est plus petite que la ligne S, la fonction renvoie -1 (valeur négative). Si la chaîne d'appel est plus grande que la ligne S, la fonction renvoie 1 (valeur positive). Si deux lignes sont égales, la fonction renvoie 0.

Exemple. Démonstration de la fonction Comparer ():

// Type String, comparer () Fonction Chaîne S1 \u003d "012345"; Chaîne s2 \u003d "0123456789"; INT res; res \u003d s1.compare (S2); // res \u003d -1 res \u003d s1.compare ("33333"); // res \u003d -1 res \u003d s1.compare ("012345"); // res \u003d 0 res \u003d s1.compare ("345"); // res \u003d -1 res \u003d s1.compare (0, 5, S2); // res \u003d -1 res \u003d s2.ca (0, 5, s1); // res \u003d -1 res \u003d s1.compare (0, 5, "012345"); // res \u003d -1 res \u003d s2.ca (S1); // res \u003d 1 res \u003d s2.ca ("456"); // res \u003d -1 res \u003d s2.ca ("000000"); // res \u003d 1

15. Obtention d'une chaîne avec la fin de la ligne '\\ 0' (char *). C_STR () Fonction. Exemple

Pour obtenir une chaîne qui se termine par un symbole ‘\0’ La fonction C_STR () est utilisée.

Fonction de prototype:

Const char * c_str () const;

La fonction est déclarée avec le modificateur Const. Cela signifie que la fonction ne peut pas changer l'appelant (chaîne).

Exemple 1.. Type de conversion String dans Cons Char *.

Chaîne s \u003d "abcdef"; Const char * ps; ps \u003d s.c_str (); // ps \u003d "abcdef"

Exemple 2.

Ci-dessous la traduction de la chaîne de la chaîne sur la chaîne du système :: String Type Pour l'afficher dans l'élément de contrôle d'étiquettes pour l'application Formulaires Windows.

// type chaîne, fonction c_str () Chaîne s \u003d "abcdef"; Chaîne SS; SS \u003d GCNEW String (S.c_str ()); // Conversion Label1-\u003e Texte \u003d SS; // affichage sur le formulaire

Hare Bonjour!

Il n'y a pas si longtemps, j'ai eu un incident assez intéressant avec moi, dans lequel l'un des enseignants d'un collège d'informatique était impliqué.

La conversation à propos de la programmation Linux s'est lentement déplacée au fait que cette personne a commencé à soutenir que la complexité de la programmation du système est effectivement extrêmement exagérée. Que la langue est simple comme une correspondance, comme le noyau Linux (de ses mots).

J'ai eu un ordinateur portable avec Linux, qui a été assisté par un gentleman Set Utilities Utilities pour la langue SI (GCC, Vim, make, Valgrind, GDB). Je ne me souviens plus de quel but nous mettons devant moi, mais dans quelques minutes, mon adversaire était derrière cet ordinateur portable, entièrement prêt à résoudre le problème.

Et littéralement aux toutes premières lignes, il a fait une grave erreur lors de l'attribution de mémoire sous ... String.

Char * str \u003d (Char *) Malloc (Tailleof (Char) * Strlen (tampon));
Tampon - la variable de pile dans laquelle les données sont entrées dans le clavier.

Je pense que nous allons certainement trouver des personnes qui demandent: "Y a-t-il quelque chose qui ne va pas ici?".
Croyez-moi, peut-être.

Et qu'est-ce que c'est exactement - lisez le chat.

Une petite théorie est une sorte de libez.

Si vous savez - feuilletez-vous jusqu'au prochain Hadera.

Une chaîne en C est une gamme de caractères qui doivent toujours mettre fin à "\\ 0" - un symbole de la fin de la chaîne. Les rangées sur la pile (statique) sont annoncées comme ceci:

Char Str [n] \u003d (0);
N est la taille de la matrice de caractères, identique à la longueur de la ligne.

Affectation (0) - Ligne "Plage" (facultatif, peut être déclarée sans elle). Le résultat est identique à celui de l'exécution des fonctions MEMSET (STR, 0, TAILLEOF (STR)) et BZERO (STR, TAILLEOF (STR)). Il est utilisé de sorte que dans des variables ininitialisées, les ordures ne mentent pas.

Également sur la pile, vous pouvez initialiser immédiatement la chaîne:

Char buf \u003d "Texte tampon par défaut \\ n";
De plus, la ligne peut être annoncée par le pointeur et allouer la mémoire sur le tas (tas).

Char * str \u003d malloc (taille);
La taille est le nombre d'octets que nous soulignons dans la chaîne. Ces lignes sont appelées dynamiques (en raison du fait que la taille souhaitée est calculée de manière dynamique + la taille de la mémoire allouée peut être augmentée à tout moment à l'aide de la fonction REALLOC ()).

Dans le cas d'une variable de pile, pour déterminer la taille de la matrice, j'ai utilisé la désignation n, dans le cas d'une variable sur un tas - j'ai utilisé la désignation Sye. Et cela reflète grandement la véritable essence de la différence avec la déclaration sur la pile de l'annonce avec l'allocation de mémoire sur le tas, car n est généralement utilisé lorsqu'ils parlent du nombre d'éléments. Et la taille est une histoire complètement différente ...

Valgrind va nous aider

Dans mon article précédent, je l'ai également mentionné. Valgrind (, Deux - Petites How-To) - Très programme utileCe qui aide le programmeur à suivre les erreurs de la fuite et de contexte de mémoire - juste ces choses qui sont le plus souvent renseignées lors de la collaboration avec des lignes.

Regardons une petite liste dans laquelle quelque chose de similaire au programme mentionné par moi est mis en œuvre et nous le montons à travers Valgrind:

#Inclure. #Inclure. #Inclure. #Define hello_string "Bonjour, hub! \\ N" vide principal () (Char * str \u003d MALLOC (Tailleof (Char)); Strcpy (Str, Hello_string); Printf ("-\u003e \\ T% S", STR); GRATUIT (Str);)
Et, en fait, le résultat du programme:

$ GCC Main.ca $ ./a.out -\u003e Bonjour, hab!
Jusqu'à présent rien n'est inhabituel. Et commençons maintenant ce programme avec Valgrind!

$ Valgrind --Tool \u003d memcheck ./a.out \u003d\u003d 3892 \u003d\u003d Memcheck, détecteur d'erreur mémoire \u003d\u003d 3892 \u003d\u003d Copyright (c) 2002-2015 et GNU GPL "D, par Julian Seward et al. \u003d\u003d 3892 \u003d\u003d à l'aide de VALGRIND-3.12.0 et de LIBVEX; RERUN AVEC -H pour Copyright Info \u003d\u003d 3892 \u003d\u003d Commande :./ve \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d Écrire non valide de taille 2 \u003d\u003d 3892 \u003d \u003d à 0x4005B4: principale (in /home/indever/prg/c/public/a.out) \u003d\u003d 3892 \u003d\u003d Adresse 0x520004C est 12 octets à l'intérieur d'un bloc de taille 13 Alloc "D \u003d\u003d 3892 \u003d\u003d à 0x4C2DB9D: MALLOC (vg_replace_malloc.c: 299) \u003d\u003d 3892 \u003d\u003d par 0x400597: Main (in /home/indever/prg/c/public/a.out) \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d Lire non valide Lecture de taille 1 \u003d\u003d 3892 \u003d\u003d à 0x4C30BC4: SHLEN (vg_replace_strmem.c: 454) \u003d\u003d 3892 \u003d\u003d par 0x4e89ad0: vfprintf (dans /usr/lib64/libc-2.24.so) \u003d\u003d 3892 \u003d\u003d par 0x4e90718: Printf (IN / USR / lib64 / libc-2.24.so) \u003d\u003d 3892 \u003d\u003d par 0x4005cf: principale (in /home/indever/prg/c/public/a.out) \u003d\u003d 3892 \u003d\u003d Adresse 0x520004D est 0 octets après un bloc de taille 13 Alloc "D \u003d\u003d 3892 \u003d\u003d à 0x4C2DB9D: MALLOC (VG_REPLACER_MALLOC.C: 299) \u003d\u003d 3892 \u003d\u003d par 0x400597: Main (in / home / Indever / PRG / C / Public / A.out) \u003d\u003d 3892 \u003d\u003d -\u003e Bonjour, hab! \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d Sommaire du tas: \u003d\u003d 3892 \u003d\u003d Utilisation à la sortie: 0 octets dans 0 blocs \u003d\u003d 3892 \u003d\u003d Total Heap Utilisation: 2 Allocs, 2 libertés, 1 037 octets alloués \u003d\u003d 3892 \u003d \u003d\u003d 3892 \u003d\u003d Tous les blocs de tas ont été libérés - aucune fuite n'est possible \u003d\u003d 3892 \u003d\u003d \u003d\u003d 3892 \u003d\u003d Pour les comptes d'erreurs détectées et supprimées, Rerun avec: -V \u003d\u003d 3892 \u003d\u003d Résumé de l'erreur: 3 erros de 2 Contextes (supprimé: 0 de 0)
\u003d\u003d 3892 \u003d\u003d Tous les blocs de tas ont été libérés - aucune fuite n'est possible - Il n'y a pas de fuites et ça veut. Mais il vaut la peine d'omettre les yeux un peu plus bas (bien que je souhaite remarquer, c'est juste le résultat, l'information principale est un peu autre lieu):

\u003d\u003d 3892 \u003d\u003d Résumé de l'erreur: 3 erreurs de 2 contextes (supprimés: 0 à partir de 0)
3 erreurs. Dans 2 contextes. Dans un programme aussi simple. Comment!?

Oui, très simple. L'ensemble de "blague" est que la fonction Strlen ne prend pas en compte le symbole de fin - "\\ 0". Même s'il est clairement indiqué dans la ligne entrante (#define Hello_string "Bonjour, hub! \\ N \\ 0"), il sera ignoré.

Juste au-dessus des résultats de l'exécution du programme, des chaînes -\u003e Bonjour, hab! Il y a un rapport détaillé qui et où je n'ai pas aimé notre précieux Valgrind. Je suggère de voir ces lignes vous-même et de tirer des conclusions.

En fait, la version correcte du programme ressemblera à ceci:

#Inclure. #Inclure. #Inclure. #Define hello_string "bonjour, hub! \\ N" vide principal () (Char * str \u003d MALLOC (taille de (caractère) + 1)); Strcpy (str, hello_string); printf ("-\u003e \\ t% s", str ); Libre (str);)
Nous passons à travers Valgrind:

$ Valgrind --Tool \u003d Memcheck ./a.out -\u003e Bonjour, hub! \u003d\u003d 3435 \u003d\u003d \u003d\u003d 3435 \u003d\u003d Résumé du tas: \u003d\u003d 3435 \u003d\u003d Utilisation à la sortie: 0 octets dans 0 blocs \u003d\u003d 3435 \u003d\u003d Utilisation totale du tas: 2 Allocs, 2 libertés, 1 038 octets alloués \u003d\u003d 3435 \u003d \u003d\u003d 3435 \u003d\u003d Tous les blocs de tas ont été libérés - aucune fuite n'est possible \u003d\u003d 3435 \u003d\u003d \u003d\u003d 3435 \u003d\u003d pour les comptes d'erreurs détectées et supprimées, RERUN avec: -V \u003d\u003d 3435 \u003d\u003d Résumé de l'erreur: 0 erreurs de 0 Contextes (supprimé: 0 de 0)
Excellent. Aucune erreur, +1 octets de mémoire allouée a permis de résoudre le problème.

Ce qui est intéressant, dans la plupart des cas et le premier et deuxième programme fonctionnera de manière égale, mais si la mémoire est allouée à une ligne dans laquelle le symbole de fin n'a pas enlève, la fonction Printf (), lorsque vous retirez une telle chaîne, fera ressortir tout La poubelle après cette ligne - tout sera affichée jusqu'à ce que le symbole d'extrémité de la chaîne ne se tient pas sur le chemin Printf ().

Cependant, vous savez, (Strlen (Str) + 1) est une solution. 2 problèmes nous lève à nous:

Et si nous devons mettre en évidence la mémoire sous forme d'utilisation, par exemple, S (n) rangée (..) rangée? Arguments que nous ne soutenons pas.
Apparence. La chaîne avec la déclaration de la variable semble affreuse. Certains gars de Malloc également (Char *) parviennent à attacher, comme s'ils écrivent sous les plus. Dans le programme où il est régulièrement requis pour traiter les chaînes. Il est logique de trouver une solution plus élégante.

Passons à une telle décision qui nous satisfera et que la valorisation.

snaprintf ()

int SnPrintf (Char * Str, Taille_t Taille, Const Char * Format, ...); - Fonction - Extension Sprintf, qui formate la chaîne et les enregistre par le pointeur transmis comme premier argument. De Sprintf (), il est caractérisé par le fait que l'octet ne sera pas écrit dans STR que la taille indiquée.

La fonction a une fonctionnalité intéressante - il renvoie la taille de la chaîne formée dans tous les cas (sans prendre en compte le symbole de caractère final). Si la chaîne est vide, puis 0 est renvoyée.

L'un des problèmes décrits par moi est lié aux fonctions Sprintf () et SNPRINTF (). Supposons que nous ayons besoin d'écrire quelque chose dans la chaîne str. La chaîne finale contient les valeurs d'autres variables. Notre disque devrait être approximativement comme celui-ci:

Char * str \u003d / * ici allouant la mémoire * /; Sprintf (str, "bonjour,% s \\ n", "Habr!");
La question se pose: comment déterminer la quantité de mémoire allouée pour la chaîne STR?

Char * str \u003d malloc (Tailleof (Char) * (Strlen (Str, "Bonjour,% s \\ n", "Habr!") + 1)); - Ça ne va pas aller. La fonction prototype SHLEN () ressemble à ceci:

#Inclure. Taille_t Strlen (Cons-Char * s);
Cons-Char * s n'implique pas que la chaîne transmise en S peut être une chaîne de format avec un nombre variable d'arguments.

Cela nous aidera à ce que la fonction utile de la fonction SnPrintf (), que j'ai parlé ci-dessus. Regardons le code programme suivant:

#Inclure. #Inclure. #Inclure. vide Main () (/ * parce que SnApRintf () ne prend pas en compte le symbole de fin, ajoutez sa taille au résultat * / Taille_t nécessaire_mem \u003d SnArCRINTF (NULL, 0, "HELLO,% S! \\ N", "HABR" ) + Tailleof ("\\ 0"); Char * str \u003d malloc (Compoissé_mem); snaprintf (str, besoin_mem, "bonjour,% s! \\ N", "Habr"); printf ("-\u003e \\ t% s" , Str); libre (str);)
Exécutez le programme dans Valgrind:

$ Valgrind --Tool \u003d Memcheck ./a.out -\u003e Bonjour, hub! \u003d\u003d 4132 \u003d\u003d \u003d\u003d 4132 \u003d\u003d Sommaire du tas: \u003d\u003d 4132 \u003d\u003d Utilisation à la sortie: 0 octets dans 0 blocs \u003d\u003d 4132 \u003d\u003d Total Heap Utilisation: 2 Allocs, 2 Frees, 1 041 octets alloués \u003d\u003d 4132 \u003d \u003d\u003d 4132 \u003d\u003d Tous les blocs de tas ont été libérés - aucune fuite n'est possible \u003d\u003d 4132 \u003d\u003d \u003d\u003d 4132 \u003d\u003d Pour les comptes d'erreurs détectées et supprimées, Rerun avec: -v \u003d\u003d 4132 \u003d\u003d Résumé de l'erreur: 0 erreurs de 0 Contextes (supprimés: 0 à 0) $
Excellent. Le soutien des arguments que nous avons. En raison du fait que nous sommes comme un deuxième argument à la fonction SnPrintf (), nous transmettons zéro, l'enregistrement par zéro pointeur ne conduira jamais à Seagfault. Cependant, malgré cette fonction retournera toujours la taille requise sous la ligne.

Mais d'autre part, nous avons dû faire une variable supplémentaire et la conception

Taille_t nécessaire_mem \u003d snaprintf (, 0, "bonjour,% s! \\ N", "HABR") + Taillef ("\\ 0");
Il a l'air encore pire que dans le cas de Strlen ().

En général, + Tailleof ("\\ 0") peut être supprimé si à la fin de la chaîne de format spécifie explicitement "\\ 0" (taille_t_mem \u003d snprintf (, 0, "bonjour,% s! \\ N \0 "," Habr ");), mais cela n'est pas toujours possible (selon le mécanisme de traitement de la ligne, nous pouvons allouer un octet supplémentaire).

Vous devez faire quelque chose. Je pensais un peu et j'ai décidé que c'était maintenant une heure pour faire appel à la sagesse des anciens. Nous décrivons la macrofonction qui causera SnPrintf () avec un pointeur zéro comme premier argument et zéro, comme la seconde. Oui, et à propos de la fin de la ligne n'oubliera pas!

#Define strtsize (args ...) snaprintf (, 0, args) + taille de ("\\ 0")
Oui, peut-être que quelqu'un sera des nouvelles, mais les macros dans Si SI soutiennent un nombre variable d'arguments, et le tryatoye indique le prétraiteur que l'argument spécifié de la macrofonction (dans notre cas que c'est des arguments) correspond à plusieurs arguments réels.

Vérifiez notre décision dans la pratique:

#Inclure. #Inclure. #Inclure. #Define strsidize (args ...) SnApRintf (, 0, args) + taille de ("\\ 0") vide () (char * str \u003d malloc (striesize ("Bonjour,% s \\ n", "Habr! ")); Sprintf (str," bonjour,% s \\ n "," Habr! "); Printf (" -\u003e \\ T% S ", STR); GRATUIT (STR););
Courir de Valgrund:

$ Valgrind --Tool \u003d Memcheck ./a.out -\u003e Bonjour, hub! \u003d\u003d 6432 \u003d\u003d \u003d\u003d 6432 \u003d\u003d Résumé du tas: \u003d\u003d 6432 \u003d\u003d Utilisation à la sortie: 0 octets dans 0 blocs \u003d\u003d 6432 \u003d\u003d Total Heap Utilisation: 2 Allocs, 2 Frees, 1 041 octets alloués \u003d\u003d 6432 \u003d \u003d\u003d 6432 \u003d\u003d Tous les blocs de tas ont été libérés - aucune fuite n'est possible \u003d\u003d 6432 \u003d\u003d \u003d\u003d 6432 \u003d\u003d pour les comptes d'erreurs détectées et supprimées, rederun avec: -V \u003d\u003d 6432 \u003d\u003d Résumé des erreurs: 0 erreurs de 0 Contextes (supprimé: 0 de 0)
Oui, il n'y a pas d'erreurs. Tous correctement. Et Valgrind satisfait et le programmeur peut enfin aller dormir.

Mais, enfin, je dis toujours quelque chose. Dans le cas où nous devons mettre en évidence la mémoire de toute ligne (même avec des arguments) est déjà entièrement fonctionnel décision prête .

Nous parlons À propos de la fonction Asprintf:

#Define _gnu_source / * Voir fonctionnalité_Test_macros (7) * / #include int asprintf (Char ** STRP, const Char * fmt, ...);
En tant que premier argument, il faut un pointeur sur la chaîne (** STRP) et alloue la mémoire pour un pointeur ressuscité.

Notre programme écrit en utilisant asprintf () va ressembler à ceci:

#Inclure. #Inclure. #Inclure. vide principal () (Char * str; Asprintf (& Str, "Bonjour,% s! \\ n", "Habr"); Printf ("-\u003e \\ T% S", STR); GRATUIT (STR););
Et, en fait, dans Valgrind:

$ Valgrind --Tool \u003d Memcheck ./a.out -\u003e Bonjour, hub! \u003d\u003d 6674 \u003d\u003d \u003d\u003d 6674 \u003d\u003d Résumé du tas: \u003d\u003d 6674 \u003d\u003d Utilisation à la sortie: 0 octets dans 0 blocs \u003d\u003d 6674 \u003d\u003d Total Heap Utilisation: 3 Allocs, 3 Frees, 1 138 octets alloués \u003d\u003d 6674 \u003d \u003d\u003d 6674 \u003d\u003d Tous les blocs de tas ont été libérés - aucune fuite n'est possible \u003d\u003d 6674 \u003d\u003d \u003d\u003d 6674 \u003d\u003d pour les comptes d'erreurs détectées et supprimées, REERUN avec: -V \u003d\u003d 6674 \u003d\u003d Sommaire d'erreur: 0 erreurs de 0 Contextes (supprimé: 0 de 0)
Tout va bien, mais comme vous le voyez, la mémoire de tout a été attribuée davantage, et Alloc "Oh maintenant trois, et pas deux. Sur des systèmes embarqués faibles, utilisez ces fonctions est indésirable.
De plus, si nous écrivions dans la console de l'homme Asprintf, nous verrons:

Les extensions GNU sont conformes à ces fonctions, non en C ou POSIX. Ils sont également disponibles sous * BSD. La mise en œuvre FreeBSD définit la STRP à NULL sur une erreur.

D'ici, il est clair que cette fonctionnalité Disponible uniquement dans les sources de GNU.

Conclusion

En conclusion, je tiens à dire que travailler avec des rangées en C est un sujet très difficile qui a un certain nombre de nuances. Par exemple, pour écrire un code "Safe" lors de l'allocation de mémoire dynamique, il est recommandé d'utiliser toujours la fonction calloc () au lieu de malloc () - CalloC marque la mémoire allouée par les zéros. Eh bien, ou après attribution de la mémoire, utilisez la fonction MEMSET (). Sinon, la poubelle, qui repose initialement sur le site de mémoire alloué, peut causer des problèmes avec un débogage et parfois lorsque vous travaillez avec une chaîne.

Plus de la moitié de mes programmeurs SI familiers (la plupart d'entre eux sont les débutants), qui ont décidé à ma demande, la tâche avec l'attribution de mémoire de la chaîne a été effectuée afin que, finalement, il a conduit à des erreurs de contexte. Dans un cas, même à la fuite de la mémoire (bien, oublié la personne à libérer (STR), avec qui cela ne se produit pas). En fait, cela m'a encouragé à créer cette création que vous venez de lire.

J'espère que cet article sera utile. Pourquoi j'avais tout d'accord, aucune langue n'est simple. Partout il y a ses subtilités. Et plus les subtilités de la langue que vous connaissez, mieux votre code.

Je crois qu'après avoir lu cet article, votre code deviendra un peu mieux :)
Bonne chance, hubr!

La bibliothèque de langues de langues C et C ++ comprend un ensemble riche de fonctions de traitement de ligne et de symbole. Les fonctions de chaîne fonctionnent avec des matrices symboliques, des symboles zéro conclus. Dans le C pour utiliser des fonctions de chaîne, vous devez activer le fichier d'en-tête au début du module de programme. , et pour le fichier d'en-tête symbolique . En C ++, des titres sont utilisés pour fonctionner avec des fonctions de chaîne et symboliques. et respectivement. Dans ce chapitre, les noms des titres C sont utilisés pour la simplicité.

Comme dans les langues C et C ++, lors de l'exécution des opérations avec des tableaux, le contrôle automatique des violations de leurs limites n'est pas fourni, toutes les responsabilités des tableaux débordants tombent sur les épaules du programmeur. Négliger ces subtilités peut conduire le programme à une défaillance d'urgence.

Dans les langues avec et C ++, les caractères affichés sur le terminal sont imprimés. Dans les environnements ASCII, ils sont situés entre un espace (0x20) et Tilda (Oxfe). Les caractères de contrôle ont les valeurs situées dans la plage entre zéro et ox1f; Ceux-ci incluent également le symbole Del (OX7F).

Historiquement, les arguments des fonctions de caractère sont les entiers dont on utilise uniquement le plus jeune octet. Les fonctions symboliques convertissent automatiquement leurs arguments en type de caractères non signé. Bien sûr, vous êtes libre d'appeler ces fonctions avec des arguments de caractère, car les caractères sont automatiquement érigés dans le rang d'entiers au moment de l'appel de la fonction.

Dans le titre Le type de taille_t est défini, qui résulte de l'utilisation de la taille de l'opérateur et est une variété de panneaux entiers.

Dans la version C99 à certains paramètres de plusieurs fonctions définies à l'origine dans la version C89, le qualificatif de restriction a été ajouté. Lorsque vous envisagez chacune une telle fonction, son prototype sera donné dans l'environnement C89 (ainsi que dans l'environnement C ++) et les paramètres avec l'attribut restrict seront marqués dans la description de cette fonction.

Liste des fonctions

Vérifiez l'appartenance

isalnum - Vérifiez l'identité du symbole à alphanumérique
isalpha - Vérification de l'identité du symbole aux lettres
isBlank - vérifier un symbole vide
iSCNTRL - Vérification d'un symbole au gestionnaire
isdigit - vérification de l'identité du symbole au numérique
isgraph - vérification de l'identité du symbole à imprimer mais non à l'espace
islower - Vérifiez l'identité du symbole à la ligne
isprint - Vérification du symbole du symbole imprimé
iSPUNCT - Vérifiez l'identité du caractère aux signes de ponctuation
isspace - Vérifiez le symbole à aveugle
isupper - Vérifiez l'identité du symbole de la capitale
isxdigit - Vérifiez l'identité du symbole à hexadécimal

Travailler avec des tableaux symboliques

mEMCHR - Parcourir un tableau pour trouver la première occurrence du symbole
mEMCMP - compare un certain nombre de caractères dans deux tableaux
memcpy - copie les caractères d'un tableau dans un autre
memmove - Copie les caractères d'un tableau à l'autre, en tenant compte du chevauchement des tableaux
mEMSET - remplit un certain nombre de caractères de tableau spécifiés

Manipulation sur les cordes

strcat - rejoint une copie d'une rangée à une donnée donnée
strchr - renvoie le pointeur à la première entrée de l'octet cadet du paramètre spécifié
sTRCMP - compare deux lignes dans l'ordre lexicographique
strcoll - compare une ligne de l'autre conformément au paramètre SetLocale
strcpy - copie le contenu d'une ligne à une autre
sTRCSPN - retourne une chaîne dans laquelle il n'y a pas de caractères spécifiés
strError - retourne un pointeur sur une chaîne contenant message système À propos de l'erreur
sHLEN - retourne la longueur de la chaîne avec le dernier symbole zéro