Calcul d'objets dynamiques à partir d'un vecteur

introduction

Disons que nous avons un ensemble d'objets avec des données et que nous devons manipuler ces objets.

Disons que l'exemple le plus courant est de remplir un panier de fruits. Nous allons implémenter une certaine classe art, dans laquelle nous ajouterons des fruits. Ensuite, nous avons besoin de la classe de base Fruit, afin de définir le paramètre de volume, auquel nous attribuerons une valeur en fonction du fruit. Le problème est résolu, les fruits sont ajoutés jusqu'à ce que le volume du panier atteigne le seuil.

Après plusieurs itérations, lorsque notre programme, pour remplir des paniers, a plié quelques poires pourries, des pommes avec des vers, ou quelque chose d'autre ne va pas, nous étendrons la classe de base Fruit, en y ajoutant des paramètres de fraîcheur, de pureté, etc., à l'état neuf. les conditions de vérification apparaissent.

Et c'est là que le problème commence. Oui, notre classe est devenue plus polyvalente, mais non seulement le nombre de problèmes avec les fruits peut augmenter, mais les situations de cueillette de fruits elles-mêmes peuvent être différentes. Par exemple, nous cueillons des fruits là où absolument tous les fruits sont frais. Pourquoi, dans ce cas, avons-nous besoin d'un champ responsable de la fraîcheur, si tous les fruits sont connus pour être frais? Pour clôturer des fonctionnalités supplémentaires pour indiquer les types obligatoires et facultatifs? - Bien sûr que non. Nous mettons un certain nombre de types optionnels dans un tableau (dictionnaire), où chaque type ne fait pas directement partie de la classe. Notre fonctionnalité est à nouveau plus intelligente, géniale.

Cependant, j'ai décidé d'aller plus loin et de développer un peu ce sujet.

Idée

Nous définissons un type qui sera chargé de stocker les variables optionnelles au format chaîne. En fait, c'est un wrapper sur un tableau. Comme ensemble minimum d'informations, nous stockerons le nom de la variable, le type (il peut s'agir de basic, int, string, bool, ou une composition de plusieurs éléments de base) et value.

Les méthodes de cet objet peuvent être variables, mais j'ai mis en évidence ce qui suit pour moi-même:

• obtenir une liste de variables et de leurs types au format chaîne (en général, vous pouvez vous limiter aux noms). Cela peut être utile si nous voulons marquer un objet avec "l'origine".

  
  
  
  
  

• getter qui renvoie notre tableau avec des informations sur les variables au format constant.

  
  
  
  
  

• obtenir l'id du type et la valeur par le nom de la variable (nécessaire pour la conversion en un type spécifique).

  
  
  
  
  

class IVariable
{
	public:

		using Type = std::variant < int, double, bool, std::string>; //     
				 

		virtual std::vector < std::pair < std::string_view, std::string_view > > abstract() = 0;
				  
		virtual std::vector < std::tuple < std::string_view, VarTypes, std::string_view > > released() = 0;

		virtual std::pair < VarTypes, std::string_view > released(const std::string_view& name) = 0;

				    
};
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , :

• , "" , .

  
  
  
  
  

, ""

bool tryVector(const std::string_view& dX)
{
	auto type = range.front()->released(dX); 

	if(type.first == VarTypes::_null) 
	{
    	return false;
	}

	for(auto&& var : _range)
	{
		if(var->released(dX).first != type.first) 
 		{
			return false;
		}
	}

	return true;  
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

• , ( tryVector).

  
  
  
  
  

, , , .

• , , .

  
  
  
  
  

• La possibilité d'ajuster la portée du travail avec des objets, lorsque, selon la situation, nous avons besoin de plus de paramètres, ou vice versa, de moins.

  
  
  
  
  

• Ne pensez pas à la façon de concevoir un objet, mais aux actions à effectuer avec l'objet

  
  
  
  
  

désavantages

• Ne convient pas pour calculer un grand nombre d'objets du même type. Par exemple, pour une classe qui définit le composant rgb d'un pixel, il sera plus efficace de définir explicitement les propriétés.

  
  
  
  
  

• Une telle approche consommera beaucoup de mémoire et, par conséquent, il est logique de ne l'utiliser que pour travailler avec des objets dont l'essence ne peut pas être exprimée en termes de plusieurs variables simples, c'est-à-dire plus pour le traitement logique des objets que pour les calculs directs.