Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Gestione della memoria nel AWS SDK per C\$1\$1
<a name="memory-management"></a>

 AWS SDK per C\$1\$1 Fornisce un modo per controllare l'allocazione e la deallocazione della memoria in una libreria.

**Nota**  
La gestione personalizzata della memoria è disponibile solo se si utilizza una versione della libreria creata utilizzando la costante in fase di compilazione definita. `USE_AWS_MEMORY_MANAGEMENT`  
Se si utilizza una versione della libreria creata senza la costante in fase di compilazione, le funzioni del sistema di memoria globale, ad esempio, `InitializeAWSMemorySystem` non funzioneranno; al loro posto vengono utilizzate `delete` le funzioni global `new` and.

Per ulteriori informazioni sulla costante in fase di compilazione, vedete [STL](#stl-and-aws-strings-and-vectors) e Strings and Vectors. AWS 

## Allocazione e deallocazione della memoria
<a name="allocating-and-deallocating-memory"></a>

 **Allocare o deallocare la memoria** 

1. Sottoclasse:. `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;
   };
   ```
**Nota**  
È possibile modificare il tipo di firma in base `AllocateMemory` alle esigenze.

1. Usa la `Aws::SDKOptions` struttura per configurare l'uso del gestore di memoria personalizzato. Passa l'istanza della struttura in`Aws::InitAPI`. Prima che l'applicazione venga terminata, l'SDK deve essere chiuso chiamando `Aws::ShutdownAPI` con la stessa istanza. 

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

## STL e stringhe e vettori AWS
<a name="stl-and-aws-strings-and-vectors"></a>

Quando inizializzato con un gestore di memoria, rinvia tutte le allocazioni e le AWS SDK per C\$1\$1 deallocazioni al gestore di memoria. Se non esiste un gestore di memoria, l'SDK utilizza global new e delete.

Se si utilizzano allocatori STL personalizzati, è necessario modificare le firme di tipo per tutti gli oggetti STL in modo che corrispondano alla politica di allocazione. Poiché STL viene utilizzato principalmente nell'implementazione e nell'interfaccia dell'SDK, un unico approccio nell'SDK impedirebbe il passaggio diretto degli oggetti STL predefiniti all'SDK o il controllo dell'allocazione STL. In alternativa, un approccio ibrido, che utilizza allocatori personalizzati internamente e consente l'utilizzo di oggetti STL standard e personalizzati sull'interfaccia, potrebbe potenzialmente rendere più difficile l'analisi dei problemi di memoria.

La soluzione consiste nell'utilizzare la costante in fase di compilazione del sistema di memoria per controllare i tipi STL utilizzati dall'SDK. `USE_AWS_MEMORY_MANAGEMENT`

Se la costante in fase di compilazione è abilitata (attiva), i tipi si risolvono in tipi STL con un allocatore personalizzato collegato al sistema di memoria. AWS 

Se la costante in fase di compilazione è disabilitata (disattivata), tutti i `Aws::*` tipi vengono risolti nel tipo predefinito corrispondente. `std::*`

 **Codice di esempio tratto dal `AWSAllocator.h` file nell'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
```

Nel codice di esempio, `AwsAllocator` può essere un allocatore personalizzato o un allocatore predefinito, a seconda della costante in fase di compilazione.

 **Codice di esempio tratto dal file nell'SDK `AWSVector.h`** 

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

Nel codice di esempio, definiamo i `Aws::*` tipi.

Se la costante in fase di compilazione è abilitata (attiva), il tipo viene mappato a un vettore utilizzando l'allocazione di memoria personalizzata e il sistema di memoria. AWS 

Se la costante in fase di compilazione è disabilitata (disattivata), il tipo viene mappato a un valore normale con parametri di tipo predefiniti. `std::vector`

L'aliasing dei tipi viene utilizzato per tutti i `std::` tipi nell'SDK che eseguono l'allocazione della memoria, come contenitori, flussi di stringhe e buffer di stringhe. Utilizza questi tipi. AWS SDK per C\$1\$1 

## Problemi rimanenti
<a name="remaining-issues"></a>

È possibile controllare l'allocazione della memoria nell'SDK; tuttavia, i tipi STL dominano ancora l'interfaccia pubblica attraverso i parametri di stringa relativi all'oggetto e ai metodi del modello. `initialize` `set` Se non si utilizza STL e si utilizzano invece stringhe e contenitori, è necessario creare molti temporanei ogni volta che si desidera effettuare una chiamata di servizio.

Per rimuovere la maggior parte delle temporanee e delle allocazioni quando si effettuano chiamate di servizio utilizzando un formato non STL, abbiamo implementato quanto segue:
+ Ogni Init/Set funzione che accetta una stringa ha un sovraccarico che richiede un. `const char*`
+ Ogni Init/Set funzione che accetta un contenitore (mappa/vettore) ha una variante di aggiunta che richiede una singola immissione.
+ Ogni Init/Set funzione che accetta dati binari ha un sovraccarico che richiede un puntatore ai dati e un valore. `length`
+ (Facoltativo) Ogni Init/Set funzione che accetta una stringa ha un sovraccarico che richiede una `const char*` terminazione diversa da zero e un valore. `length`

## Sviluppatori SDK nativi e controlli di memoria
<a name="native-sdk-developers-and-memory-controls"></a>

Segui queste regole nel codice SDK:
+ Non usare `new` e`delete`; usa `Aws::New<>` e `Aws::Delete<>` invece.
+ Non usare `new[]` e`delete[]`; usa `Aws::NewArray<>` e`Aws::DeleteArray<>`.
+ Non usare`std::make_shared`; usare`Aws::MakeShared`.
+ `Aws::UniquePtr`Utilizzatelo per puntatori univoci a un singolo oggetto. Utilizzate la `Aws::MakeUnique` funzione per creare il puntatore univoco.
+ `Aws::UniqueArray`Utilizzatelo per puntatori univoci a una serie di oggetti. Utilizzate la `Aws::MakeUniqueArray` funzione per creare il puntatore univoco.
+ Non utilizzate direttamente contenitori STL; usate uno dei typedef o aggiungete un `Aws::` typedef per il contenitore che desiderate. Esempio:

  ```
  Aws::Map<Aws::String, Aws::String> m_kvPairs;
  ```
+ `shared_ptr`Utilizzatelo per qualsiasi puntatore esterno passato e gestito dall'SDK. È necessario inizializzare il puntatore condiviso con una politica di distruzione che corrisponda al modo in cui l'oggetto è stato allocato. È possibile utilizzare un puntatore non elaborato se non si prevede che l'SDK pulisca il puntatore.