Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

🌈个人主页：Camarade de classe Yuchen 

💫个人格言:“成为自己未来的主人~”   

Voici les fonctions de String que nous allons implémenter dans cet article :

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
 
namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin();
		iterator end();
 
		string(const char* str = "");
		~string();
		const char* c_str() const;
		size_t size() const;
		char& operator[](size_t pos);
	private:
		char* _str;
		size_t size;
		size_t _capacity;
	};
}

Parmi ces fonctions

string(const char* str = "");

Le but d'écrire ainsi est principalement de prendre en compte les chaînes vides et d'ajouter une valeur par défaut. Si la chaîne entrante est vide, elle sera automatiquement copiée sur "0".

const char* c_str() const;
		size_t size() const;

Dans ces deux lignes de code, l'objectif principal de l'ajout de const est de garantir que ces deux fonctions peuvent être appelées, que la chaîne de taille transmise soit modifiable ou non.

Nous mettons les codes ci-dessus dans le fichier d'en-tête.

Dans le fichier .cpp, nous l'utilisons pour implémenter ces fonctions.

#include"String.h"

Nous introduisons le fichier d'en-tête au début du fichier .cpp. Certains étudiants peuvent être curieux de savoir s'il entrera en conflit avec le fichier String.h dans la bibliothèque C++, mais le résultat ne l'est pas car le compilateur recherchera dans le répertoire actuel, et le courant Le fichier existe déjà dans le répertoire.

#define _CRT_SECURE_NO_WARNINGS
#include"String.h"
namespace bit
{
	string::iterator string::begin()
	{
		return _str;
	}
	string::iterator string::end()
	{
		return _str + _size;
	}
 
	string::string(const char* str)
		:_size(strlen(str))
	{
		_str = new char[_size + 1];
		_capacity = _size;
		strcpy(_str, str);
	}
	string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}
	const char* string::c_str() const
	{
		return _str;
	}
	size_t string::size() const
	{
		return _size;
	}
	char& string::operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}
 
}

Il s’agit de l’implémentation de base du code String.

Ce qui suit est le fichier de test pour cette chaîne

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include"String.h"
namespace bit
{
	void test_string1()
	{
		bit::string s1("hello world");
		cout << s1.c_str() << endl;
		for (size_t i = 0; i < s1.size(); i++)
		{
			s1[i]++;
		}
		for (size_t i = 0; i < s1.size(); i++)
		{
			cout << s1[i] << " ";
		}
		cout << endl;
		string::iterator it1 = s1.begin();
		while (it1 != s1.end())
		{
			cout << *it1 << " ";
			++it1;
		}
		cout << endl;
		for (auto e : s1)
		{
			cout << e << " ";
		}
		cout << endl;
		bit::string s2;
		cout << s2.c_str() << endl;
	}
}
int main()
{
	bit::test_string1();
 
	return 0;
}

En fait, pour la gamme for, sa couche inférieure est un itérateur, et l'itérateur est principalement un package. Les différents types en bas sont renommés avec itérateur pour construire une superstructure unifiée.

Par conséquent, tant que l’itérateur de base est construit, range for peut être utilisé.