[Connaissance de base C ++] classe de chaînes

classe de chaîne

Constructeur:

string (); // default constructeur
string (const string & str); // copie de la
chaîne du constructeur (const string & str, size_t pos, size_t len ​​= npos); // sous-chaîne constructeur
string (const char * s); // Utilisez la chaîne de style langage C pour construire la
chaîne (const char * s, size_t n); // Copie les n premiers caractères du tableau de caractères pointé par s.
string (size_t n, char c); // Remplit la chaîne avec n copies consécutives du caractère c.

template <class InputIterator>
string (InputIterator en premier, InputIterator en dernier); // Utiliser un itérateur pour construire une chaîne

Exemple:

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
void test()
{
    
    
	string str;
	string str1("abcdefgh");
	string str2(str1);
	string str3(str1,0,5);
	string str4("zxcvbnm",5);
	string str5(5,'x');
}

int main()
{
    
    
	test();
	return 0;
}

résultat:

Interface d'opération de capacité pour les objets de chaîne

Nom de la fonction	Fonctionnalités
Taille	Renvoie la longueur de caractère effective de la chaîne
longueur	Renvoie la longueur de caractère effective de la chaîne
capacité	Renvoie la taille de la capacité
vider	Vérifiez si la chaîne est vide, renvoie true si oui, false si non
dégager	Effacer les caractères valides
réserve	Ajuster la taille de la capacité des cordes
redimensionner	Définissez le nombre de caractères valides sur n et remplissez l'espace supplémentaire avec le caractère c

Remarque:

1. Le principe d'implémentation sous-jacent de size () est exactement le même que celui de length (). La raison de l'introduction de size () est d'être cohérent avec les interfaces des autres conteneurs. En général, size () est essentiellement utilisé.
2. clear () efface uniquement les caractères valides de la chaîne sans changer la taille de l'espace sous-jacent.
3. Les deux redimensionner (size_t n) et redimensionner (size_t n, car c) changent le nombre de caractères valides dans la chaîne en n, la différence est que lorsque le nombre de caractères augmente: resize (n) est rempli avec 0 Espace d'élément, redimensionner (size_t n, char c) utilise le caractère c pour remplir l'espace d'élément supplémentaire.
   Remarque: lorsque le redimensionnement modifie le nombre d'éléments, si le nombre d'éléments est augmenté, la taille de la capacité sous-jacente peut être modifiée. Si le nombre d'éléments est réduit, la taille totale de l'espace sous-jacent reste inchangée.
4. reserve (size_t res_arg = 0): Réserver de l'espace pour la chaîne sans changer le nombre d'éléments effectifs. Lorsque le paramètre de reserve est inférieur à
   la taille totale de l'espace sous-jacent de la chaîne, le serveur ne modifiera pas la capacité.

chaîne :: opérateur + =

+ = équivaut à l'opération de la
chaîne d' insertion de queue & operator + = (const string & str);
string & operator + = (const char * s);
string & operator + = (char c);

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;

int main()
{
    
    
	string str1;
	string str2 = "123";
	str1 += str2;//123
	str1 += "abc";//123abc
	str1 += 'x';//123abcx

	return 0;
}

string :: append

Développez la chaîne en ajoutant d'autres caractères à la fin de la valeur actuelle de la chaîne

string & append (const string & str);
string & append (const string & str, size_t subpos, size_t sublen);
string & append (const char * s);
string & append (const char * s, size_t n);
string & append (size_t n, char c);

template <classe InputIterator>

string & append (InputIterator en premier, InputIterator en dernier);

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;

int main()
{
    
    
	string str;
	string str2 = "123";
	
	//string& append(const string& str);
	str.append(str2);//123
	str.append(str2);//123123
	cout << str << endl;

	//string& append(const string& str, size_t subpos, size_t sublen);
	str.append(str2,0,2);//12312312
	cout << str << endl;


	//string& append(const char* s);
	str.append("abc");//12312312abc
	cout << str << endl;


	//string& append(const char* s, size_t n);
	str.append("zxcvbnm",4);//12312312abczxcv
	cout << str << endl;

    //string& append(size_t n, char c);
	str.append(3,'x');//12312312abczxcvxxx
	cout << str << endl;

	/*template \<class InputIterator>
		string& append (InputIterator first, InputIterator last);*/
	str.append(str2.begin(),str2.end());//12312312abczxcvxxx123
	cout << str << endl;

	char s[] = "369";
	str.append(s, s + sizeof(s) / sizeof(s[0]));//12312312abczxcvxxx123369
	cout << str << endl;

	return 0;
}

Résultat de sortie:

string :: insert

string & insert (size_t pos, const string & str);
string & insert (size_t pos, const string & str, size_t subpos, size_t sublen);
string & insert (size_t pos, const char * s);
string & insert (size_t pos, const char * s, size_t n);
string & insert (size_t pos, size_t n, char c);
insert vide (itérateur p, size_t n, car c);
insert d'itérateur (itérateur p, car c);
template <classe InputIterator>

insert vide (itérateur p, InputIterator en premier, InputIterator en dernier);

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;


int main()
{
    
    
	string str = "mm";
	string str2 = "123";
	//string& insert(size_t pos, const string& str);
	str.insert(1,str2);//m123m
	cout << str << endl;

	//string& insert(size_t pos, const string& str, size_t subpos, size_t sublen);
	str.insert(1,str2,1,2);//m23123m
	cout << str << endl;

	//string& insert(size_t pos, const char* s);
	str.insert(0,"abc");//abcm23123m
	cout << str << endl;

	//string& insert(size_t pos, const char* s, size_t n);
	str.insert(0,"000000",5);//00000zbcm23123m
	cout << str << endl;

	/*string& insert(size_t pos, size_t n, char c);
	void insert(iterator p, size_t n, char c);*/
	str.insert(str.begin(),3,'x');//xxx00000zbcm23123m
	cout << str << endl;

	//iterator insert(iterator p, char c);
	
	/*template \<class InputIterator>
		>> void insert(iterator p, InputIterator first, InputIterator last);*/
	str.insert(str.end(),str2.begin(),str2.end());//xxx00000zbcm23123m123

	cout << str << endl;


}

résultat de l'opération: