Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Gestion de la mémoire dans le AWS SDK pour C\$1\$1
<a name="memory-management"></a>

 AWS SDK pour C\$1\$1 Il fournit un moyen de contrôler l'allocation et la désallocation de mémoire dans une bibliothèque.

**Note**  
La gestion personnalisée de la mémoire n'est disponible que si vous utilisez une version de la bibliothèque créée à l'aide de la constante de compilation définie. `USE_AWS_MEMORY_MANAGEMENT`  
Si vous utilisez une version de la bibliothèque construite sans la constante de compilation, les fonctions du système de mémoire global telles que celles-ci ne `InitializeAWSMemorySystem` fonctionneront pas ; les `delete` fonctions globales `new` et sont utilisées à la place.

Pour plus d'informations sur la constante de compilation, consultez [STL et AWS Chaînes et vecteurs](#stl-and-aws-strings-and-vectors).

## Allocation et désallocation de mémoire
<a name="allocating-and-deallocating-memory"></a>

 **Pour allouer ou désallouer de la mémoire** 

1. Sous-classe `MemorySystemInterface` :`aws/core/utils/memory/MemorySystemInterface.h`.

   ```
   class MyMemoryManager : public Aws::Utils::Memory::MemorySystemInterface
   {
   public:
       // ...
       virtual void* AllocateMemory(
           std::size_t blockSize, std::size_t alignment,
           const char *allocationTag = nullptr) override;
       virtual void FreeMemory(void* memoryPtr) override;
   };
   ```
**Note**  
Vous pouvez modifier le type de signature `AllocateMemory` selon vos besoins.

1. Utilisez la `Aws::SDKOptions` structure pour configurer l'utilisation du gestionnaire de mémoire personnalisé. Passez l'instance de la structure dans`Aws::InitAPI`. Avant que l'application ne s'arrête, le SDK doit être arrêté en appelant `Aws::ShutdownAPI` avec la même instance. 

   ```
   int main(void)
   {
     MyMemoryManager sdkMemoryManager;
     SDKOptions options;
     options.memoryManagementOptions.memoryManager = &sdkMemoryManager;
     Aws::InitAPI(options);
   
     // ... do stuff
   
     Aws::ShutdownAPI(options);
   
     return 0;
   }
   ```

## STL, AWS chaînes et vecteurs
<a name="stl-and-aws-strings-and-vectors"></a>

Lorsqu'il est initialisé avec un gestionnaire de mémoire, toutes les allocations et AWS SDK pour C\$1\$1 désallocations sont reportées au gestionnaire de mémoire. S'il n'existe pas de gestionnaire de mémoire, le SDK utilise global new et delete.

Si vous utilisez des allocateurs STL personnalisés, vous devez modifier les signatures de type de tous les objets STL afin qu'elles correspondent à la politique d'allocation. Le STL étant largement utilisé dans l'implémentation et l'interface du SDK, une approche unique du SDK empêcherait le transfert direct d'objets STL par défaut dans le SDK ou le contrôle de l'allocation STL. Par ailleurs, une approche hybride, utilisant des allocateurs personnalisés en interne et autorisant des objets STL standard et personnalisés sur l'interface, pourrait potentiellement compliquer l'étude des problèmes de mémoire.

La solution consiste à utiliser la constante de compilation du système de mémoire `USE_AWS_MEMORY_MANAGEMENT` pour contrôler les types STL utilisés par le SDK.

Si la constante de compilation est activée (activée), les types sont convertis en types STL avec un allocateur personnalisé connecté au système de mémoire. AWS 

Si la constante de compilation est désactivée (désactivée), tous les `Aws::*` types sont résolus dans le type par défaut `std::*` correspondant.

 **Exemple de code issu du `AWSAllocator.h` fichier du SDK** 

```
#ifdef USE_AWS_MEMORY_MANAGEMENT

template< typename T >
class AwsAllocator : public std::allocator< T >
{
   ... definition of allocator that uses AWS memory system
};

#else

template< typename T > using Allocator = std::allocator<T>;

#endif
```

Dans l'exemple de code, il `AwsAllocator` peut s'agir d'un allocateur personnalisé ou d'un allocateur par défaut, selon la constante de compilation.

 **Exemple de code issu du `AWSVector.h` fichier du SDK** 

```
template<typename T> using Vector = std::vector<T, Aws::Allocator<T>>;
```

Dans l'exemple de code, nous définissons les `Aws::*` types.

Si la constante de compilation est activée (activée), le type est mappé sur un vecteur en utilisant l'allocation de mémoire personnalisée et le système de AWS mémoire.

Si la constante de compilation est désactivée (désactivée), le type correspond à une valeur normale `std::vector` avec des paramètres de type par défaut.

L'alias de type est utilisé pour tous les `std::` types du SDK qui effectuent l'allocation de mémoire, tels que les conteneurs, les flux de chaînes et les tampons de chaînes. Ils AWS SDK pour C\$1\$1 utilisent ces types.

## Problèmes en suspens
<a name="remaining-issues"></a>

Vous pouvez contrôler l'allocation de mémoire dans le SDK ; toutefois, les types STL dominent toujours l'interface publique par le biais de paramètres de chaîne destinés à l'objet `initialize` et `set` aux méthodes du modèle. Si vous n'utilisez pas le protocole STL et que vous utilisez plutôt des chaînes et des conteneurs, vous devez créer de nombreux temporaires chaque fois que vous souhaitez effectuer un appel de service.

Pour supprimer la plupart des temporaires et des allocations lorsque vous passez des appels de service en utilisant un protocole autre que le protocole STL, nous avons mis en œuvre les mesures suivantes :
+ Chaque Init/Set fonction qui prend une chaîne a une surcharge qui prend un`const char*`.
+ Chaque Init/Set fonction qui prend un conteneur (carte/vecteur) possède une variante d'ajout qui ne prend qu'une seule entrée.
+ Chaque Init/Set fonction qui prend des données binaires a une surcharge qui prend un pointeur vers les données et une `length` valeur.
+ (Facultatif) Chaque Init/Set fonction qui accepte une chaîne présente une surcharge qui prend une terminaison différente de zéro `const char*` et une `length` valeur.

## Développeurs de SDK natifs et contrôles de mémoire
<a name="native-sdk-developers-and-memory-controls"></a>

Suivez les règles suivantes dans le code du SDK :
+ N'utilisez pas `new` et `delete` ; utilisez `Aws::New<>` et à la `Aws::Delete<>` place.
+ N'utilisez pas `new[]` et `delete[]` ; utilisez `Aws::NewArray<>` et`Aws::DeleteArray<>`.
+ N'utilisez pas `std::make_shared` ; utilisez`Aws::MakeShared`.
+ `Aws::UniquePtr`À utiliser pour des pointeurs uniques vers un seul objet. Utilisez la `Aws::MakeUnique` fonction pour créer le pointeur unique.
+ `Aws::UniqueArray`À utiliser pour des pointeurs uniques vers un ensemble d'objets. Utilisez la `Aws::MakeUniqueArray` fonction pour créer le pointeur unique.
+ N'utilisez pas directement les conteneurs STL ; utilisez l'un des `Aws::` typedefs ou ajoutez un typedef pour le conteneur de votre choix. Par exemple :

  ```
  Aws::Map<Aws::String, Aws::String> m_kvPairs;
  ```
+ `shared_ptr`À utiliser pour tout pointeur externe transmis et géré par le SDK. Vous devez initialiser le pointeur partagé avec une politique de destruction correspondant à la manière dont l'objet a été alloué. Vous pouvez utiliser un pointeur brut si le SDK n'est pas censé le nettoyer.