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à.

# Usare l' AWS SDK per C\$1\$1
<a name="programming-general"></a>

Questa sezione fornisce informazioni sull'uso generale di AWS SDK per C\$1\$1, oltre a quanto descritto in Guida [introduttiva all'uso](getting-started.md) di AWS SDK per C\$1\$1.

Per esempi di programmazione specifici del servizio, vedere Esempi di [AWS SDK per C\$1\$1 codice.](programming-services.md)

**Topics**
+ [Inizializzazione e chiusura dell'SDK](basic-use.md)
+ [Effettuare richieste Servizio AWS](using-service-client.md)
+ [Programmazione asincrona](async-methods.md)
+ [Moduli di utilità](utility-modules.md)
+ [Gestione della memoria](memory-management.md)
+ [Gestione degli errori](error-handling.md)

# Inizializzazione e spegnimento di AWS SDK per C\$1\$1
<a name="basic-use"></a>

Le applicazioni che utilizzano il AWS SDK per C\$1\$1 devono inizializzarlo. Allo stesso modo, prima che l'applicazione venga terminata, è necessario chiudere l'SDK. Entrambe le operazioni accettano opzioni di configurazione che influiscono sui processi di inizializzazione e chiusura e sulle successive chiamate all'SDK.

Tutte le applicazioni che utilizzano il AWS SDK per C\$1\$1 devono includere il file. `aws/core/Aws.h`

 AWS SDK per C\$1\$1 Deve essere inizializzato `Aws::InitAPI` chiamando. Prima che l'applicazione venga terminata, l'SDK deve essere chiuso chiamando. `Aws::ShutdownAPI` Ogni metodo accetta un argomento di. [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/struct_aws_1_1_s_d_k_options.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/struct_aws_1_1_s_d_k_options.html) Tutte le altre chiamate all'SDK possono essere eseguite tra queste due chiamate al metodo.

**Tutte le AWS SDK per C\$1\$1 chiamate eseguite tra `Aws::InitAPI` e `Aws::ShutdownAPI` devono essere contenute in un paio di parentesi graffe o devono essere richiamate da funzioni chiamate tra i due metodi.**

Di seguito viene mostrata un'applicazione Skeleton di base.

```
#include <aws/core/Aws.h>
int main(int argc, char** argv)
{
   Aws::SDKOptions options;
   Aws::InitAPI(options);
   {
      // make your SDK calls here.
   }
   Aws::ShutdownAPI(options);
   return 0;
}
```

**L'SDK for C\$1\$1 e le sue dipendenze utilizzano oggetti statici C\$1\$1 e l'ordine di distruzione degli oggetti statici non è determinato dallo standard C\$1\$1. Per evitare problemi di memoria causati dall'ordine non deterministico di distruzione delle variabili statiche, non inserite le chiamate da e verso un altro oggetto statico. `Aws::InitAPI` `Aws::ShutdownAPI`**

# Effettuare Servizio AWS richieste utilizzando l' AWS SDK for C\$1\$1
<a name="using-service-client"></a>

 Per accedere a livello di codice Servizi AWS, SDKs usa una classe client per ciascuno. Servizio AWS Ad esempio, se la tua applicazione deve accedere ad Amazon EC2, crea un oggetto EC2 client Amazon per interfacciarsi con quel servizio. Quindi utilizzi il client del servizio per effettuare richieste in merito Servizio AWS. 

Per fare una richiesta a un Servizio AWS, devi prima creare e [configurare](configuring.md) un client di servizio. Per ogni Servizio AWS codice utilizzato, ha una propria libreria e un tipo dedicato per interagire con esso. Il client espone un metodo per ogni operazione API esposta dal servizio. 

Lo spazio dei nomi per una classe client segue la convenzione. `Aws::Service::ServiceClient` Ad esempio, la classe client for AWS Identity and Access Management (IAM) è `Aws::IAM::IAMClient` e la classe client Amazon S3 è. `Aws::S3::S3Client`

Tutte le classi client per tutti i AWS servizi sono thread-safe.

Quando si crea un'istanza di una classe client, AWS è necessario fornire le credenziali. Le credenziali possono essere fornite dal codice, dall'ambiente o dal file condiviso e dal AWS `config` file condiviso. `credentials` Per ulteriori informazioni sulle credenziali, consulta [le istruzioni per configurare l'autenticazione IAM Identity Center consigliata](credentials.md) o utilizza [un altro provider di credenziali disponibile](credproviders.md).

# Programmazione asincrona mediante AWS SDK per C\$1\$1
<a name="async-methods"></a>

## metodi SDK asincroni
<a name="asynchronous-sdk-methods"></a>

Per molti metodi, l'SDK for C\$1\$1 fornisce versioni sia sincrone che asincrone. Un metodo è asincrono se include il suffisso nel nome. `Async` Ad esempio, il metodo Amazon S3 è sincrono, mentre `PutObject` `PutObjectAsync` è asincrono.

Come tutte le operazioni asincrone, un metodo SDK asincrono viene restituito prima del termine dell'attività principale. Ad esempio, il `PutObjectAsync` metodo restituisce prima del completamento del caricamento del file nel bucket Amazon S3. Mentre l'operazione di caricamento continua, l'applicazione può eseguire altre operazioni, inclusa la chiamata di altri metodi asincroni. L'applicazione viene informata che un'operazione asincrona è terminata quando viene richiamata una funzione di callback associata.

Le sezioni seguenti descrivono un esempio di codice che dimostra la chiamata al metodo asincrono. `PutObjectAsync` [Ogni sezione si concentra su singole parti dell'intero file sorgente dell'esempio.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_async.cpp)

## Chiamata di metodi asincroni SDK
<a name="calling-sdk-asynchronous-methods"></a>

In generale, la versione asincrona di un metodo SDK accetta i seguenti argomenti.
+ Un riferimento allo stesso oggetto di tipo Request-type della sua controparte sincrona.
+ Un riferimento a una funzione di callback del gestore di risposte. Questa funzione di callback viene richiamata al termine dell'operazione asincrona. Uno degli argomenti contiene il risultato dell'operazione.
+ Opzionale `shared_ptr` per un `AsyncCallerContext` oggetto. L'oggetto viene passato al callback del gestore di risposte. Include una proprietà UUID che può essere utilizzata per passare informazioni di testo al callback.

Il `uploadFileAsync` metodo illustrato di seguito configura e chiama il metodo Amazon `PutObjectAsync` S3 dell'SDK per caricare in modo asincrono un file su un bucket Amazon S3.

La funzione riceve riferimenti a un oggetto e a un oggetto. `S3Client` `PutObjectRequest` Li riceve dalla funzione principale perché dobbiamo assicurarci che questi oggetti esistano per tutta la durata delle chiamate asincrone.

A `shared_ptr` a un `AsyncCallerContext` oggetto viene assegnato. `UUID`La sua proprietà è impostata sul nome dell'oggetto Amazon S3. A scopo dimostrativo, il callback del gestore di risposte accede alla proprietà e ne restituisce il valore.

La chiamata a `PutObjectAsync` include un argomento di riferimento alla funzione di callback del gestore della risposta. `uploadFileAsyncFinished` Questa funzione di callback viene esaminata più dettagliatamente nella sezione successiva.

```
bool AwsDoc::S3::uploadFileAsync(const Aws::S3::S3Client &s3Client,
                                Aws::S3::Model::PutObjectRequest &request,
                                const Aws::String &bucketName,
                                const Aws::String &fileName) {
    request.SetBucket(bucketName);
    request.SetKey(fileName);

    const std::shared_ptr<Aws::IOStream> input_data =
            Aws::MakeShared<Aws::FStream>("SampleAllocationTag",
                                          fileName.c_str(),
                                          std::ios_base::in | std::ios_base::binary);

    if (!*input_data) {
        std::cerr << "Error: unable to open file " << fileName << std::endl;
        return false;
    }

    request.SetBody(input_data);

    // Create and configure the context for the asynchronous put object request.
    std::shared_ptr<Aws::Client::AsyncCallerContext> context =
            Aws::MakeShared<Aws::Client::AsyncCallerContext>("PutObjectAllocationTag");
    context->SetUUID(fileName);

    // Make the asynchronous put object call. Queue the request into a 
    // thread executor and call the uploadFileAsyncFinished function when the
    // operation has finished. 
    s3Client.PutObjectAsync(request, uploadFileAsyncFinished, context);

    return true;
}
```

Le risorse per un'operazione asincrona devono esistere fino al termine dell'operazione. Ad esempio, gli oggetti client e request devono esistere fino a quando l'applicazione non riceve la notifica del completamento dell'operazione. L'applicazione stessa non può terminare fino al completamento dell'operazione asincrona.

Per questo motivo, il `uploadFileAsync` metodo accetta riferimenti a `PutObjectRequest` oggetti `S3Client` e anziché crearli nel `uploadFileAsync` metodo e memorizzarli in una variabile locale. 

Nell'esempio, il `PutObjectAsync` metodo ritorna al chiamante immediatamente dopo l'inizio dell'operazione asincrona, consentendo alla catena di chiamata di eseguire attività aggiuntive mentre è in corso l'operazione di caricamento. 

Se il client fosse memorizzato in una variabile locale del `uploadFileAsync` metodo, non rientrerebbe nell'ambito di applicazione al momento della restituzione del metodo. Tuttavia, l'oggetto client deve continuare a esistere fino al termine dell'operazione asincrona.

## Notifica del completamento di un'operazione asincrona
<a name="notification-of-the-completion-of-an-asynchronous-operation"></a>

Al termine di un'operazione asincrona, viene richiamata una funzione di callback del gestore della risposta dell'applicazione. Questa notifica include l'esito dell'operazione. Il risultato è contenuto nella stessa classe di tipo Outcome restituita dalla controparte sincrona del metodo. Nell'esempio di codice, il risultato è in un oggetto. `PutObjectOutcome`

La funzione di callback del gestore di risposte dell'esempio `uploadFileAsyncFinished` è mostrata di seguito. Verifica se l'operazione asincrona è riuscita o fallita. Utilizza a `std::condition_variable` per notificare al thread dell'applicazione che l'operazione asincrona è terminata.

```
// A mutex is a synchronization primitive that can be used to protect shared
// data from being simultaneously accessed by multiple threads.
std::mutex AwsDoc::S3::upload_mutex;

// A condition_variable is a synchronization primitive that can be used to
// block a thread, or to block multiple threads at the same time.
// The thread is blocked until another thread both modifies a shared
// variable (the condition) and notifies the condition_variable.
std::condition_variable AwsDoc::S3::upload_variable;
```

```
void uploadFileAsyncFinished(const Aws::S3::S3Client *s3Client,
                            const Aws::S3::Model::PutObjectRequest &request,
                            const Aws::S3::Model::PutObjectOutcome &outcome,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext> &context) {
    if (outcome.IsSuccess()) {
        std::cout << "Success: uploadFileAsyncFinished: Finished uploading '"
                  << context->GetUUID() << "'." << std::endl;
    } else {
        std::cerr << "Error: uploadFileAsyncFinished: " <<
                  outcome.GetError().GetMessage() << std::endl;
    }

    // Unblock the thread that is waiting for this function to complete.
    AwsDoc::S3::upload_variable.notify_one();
}
```

Al termine dell'operazione asincrona, le risorse ad essa associate possono essere rilasciate. L'applicazione può anche terminare se lo desidera.

Il codice seguente mostra come i `uploadFileAsyncFinished` metodi `uploadFileAsync` and vengono utilizzati da un'applicazione.

L'applicazione alloca gli `PutObjectRequest` oggetti `S3Client` and in modo che continuino a esistere fino al termine dell'operazione asincrona. Dopo la chiamata`uploadFileAsync`, l'applicazione può eseguire tutte le operazioni desiderate. Per semplicità, nell'esempio viene utilizzato un comando `std::mutex` and `std::condition_variable` to wait che il callback del gestore di risposta lo informi che l'operazione di caricamento è terminata.

```
int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        std::cout << R"(
Usage:
    run_put_object_async <file_name> <bucket_name>
Where:
    file_name - The name of the file to upload.
    bucket_name - The name of the bucket to upload the object to.
)" << std::endl;
        return 1;
    }

    const Aws::SDKOptions options;
    Aws::InitAPI(options);
    {
        const Aws::String fileName = argv[1];
        const Aws::String bucketName = argv[2];

        // A unique_lock is a general-purpose mutex ownership wrapper allowing
        // deferred locking, time-constrained attempts at locking, recursive
        // locking, transfer of lock ownership, and use with
        // condition variables.
        std::unique_lock<std::mutex> lock(AwsDoc::S3::upload_mutex);

        // Create and configure the Amazon S3 client.
        // This client must be declared here, as this client must exist
        // until the put object operation finishes.
        const Aws::S3::S3ClientConfiguration config;
        // Optional: Set to the AWS Region in which the bucket was created (overrides config file).
        // config.region = "us-east-1";

        const Aws::S3::S3Client s3Client(config);

        // Create the request object.
        // This request object must be declared here, because the object must exist
        // until the put object operation finishes.
        Aws::S3::Model::PutObjectRequest request;

        AwsDoc::S3::uploadFileAsync(s3Client, request, bucketName, fileName);

        std::cout << "main: Waiting for file upload attempt..." <<
                  std::endl << std::endl;

        // While the put object operation attempt is in progress,
        // you can perform other tasks.
        // This example simply blocks until the put object operation
        // attempt finishes.
        AwsDoc::S3::upload_variable.wait(lock);

        std::cout << std::endl << "main: File upload attempt completed."
                  << std::endl;
    }
    Aws::ShutdownAPI(options);

    return 0;
}
```

Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_async.cpp) su GitHub.

# Moduli di utilità disponibili in AWS SDK per C\$1\$1
<a name="utility-modules"></a>

 AWS SDK per C\$1\$1 Include molti [moduli di utilità](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/namespace_aws_1_1_utils.html) per ridurre la complessità dello sviluppo di AWS applicazioni in C\$1\$1.

## Stack HTTP
<a name="http-stack"></a>

Uno stack HTTP che fornisce il pool di connessioni, è thread-safe e può essere riutilizzato in base alle esigenze. [Per ulteriori informazioni, consulta Configurazione del client.AWS](client-config.md)


****  

|  |  | 
| --- |--- |
|  Headers  |   [https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/http](https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/http)   | 
|  Documentazione API  |   [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/namespace_aws_1_1_http.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/namespace_aws_1_1_http.html)   | 

## String Utils
<a name="string-utils"></a>

Funzioni di stringa di base, come `trim``lowercase`, e conversioni numeriche.


****  

|  |  | 
| --- |--- |
|  Header  |   [https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/StringUtils.h](https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/StringUtils.h)   | 
|  Documentazione API  |   [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_string_utils.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_string_utils.html)   | 

## Utilità di hashing
<a name="hashing-utils"></a>

Funzioni di hashing come`SHA256`,`MD5`, `Base64` e. `SHA256_HMAC`


****  

|  |  | 
| --- |--- |
|  Header  |   [https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/HashingUtils.h](https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/HashingUtils.h)   | 
|  Documentazione API  |   [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_hashing_utils.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_hashing_utils.html)   | 

## Parser JSON
<a name="json-parser"></a>

Un parser JSON completamente funzionante ma leggero (un involucro sottile). *`cJSON`*


****  

|  |  | 
| --- |--- |
|  Header  |   [https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/json/JsonSerializer.h](https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/json/JsonSerializer.h)   | 
|  Documentazione API  |   [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_json_1_1_json_value.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/class_aws_1_1_utils_1_1_json_1_1_json_value.html)   | 

## Parser XML
<a name="xml-parser"></a>

Un parser XML leggero (un involucro sottile). *`tinyxml2`* Il [pattern RAII](http://en.cppreference.com/w/cpp/language/raii) è stato aggiunto all'interfaccia.


****  

|  |  | 
| --- |--- |
|  Header  |   [https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/xml/XmlSerializer.h](https://github.com/aws/aws-sdk-cpp/tree/master/aws-cpp-sdk-core/include/aws/core/utils/xml/XmlSerializer.h)   | 
|  Documentazione API  |   [https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/namespace_aws_1_1_utils_1_1_xml.html](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/namespace_aws_1_1_utils_1_1_xml.html)   | 

# 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.

# Gestione degli errori nell' AWS SDK for C\$1\$1
<a name="error-handling"></a>

 AWS SDK per C\$1\$1 Non utilizza eccezioni; tuttavia, è possibile utilizzare eccezioni nel codice. Ogni client di servizio restituisce un oggetto risultato che include il risultato e un codice di errore.

 **Esempio di gestione delle condizioni di errore** 

```
bool CreateTableAndWaitForItToBeActive()
{
  CreateTableRequest createTableRequest;
  AttributeDefinition hashKey;
  hashKey.SetAttributeName(HASH_KEY_NAME);
  hashKey.SetAttributeType(ScalarAttributeType::S);
  createTableRequest.AddAttributeDefinitions(hashKey);
  KeySchemaElement hashKeySchemaElement;
  hashKeySchemaElement.WithAttributeName(HASH_KEY_NAME).WithKeyType(KeyType::HASH);
  createTableRequest.AddKeySchema(hashKeySchemaElement);
  ProvisionedThroughput provisionedThroughput;
  provisionedThroughput.SetReadCapacityUnits(readCap);
  provisionedThroughput.SetWriteCapacityUnits(writeCap);
  createTableRequest.WithProvisionedThroughput(provisionedThroughput);
  createTableRequest.WithTableName(tableName);

  CreateTableOutcome createTableOutcome = dynamoDbClient->CreateTable(createTableRequest);
  if (createTableOutcome.IsSuccess())
  {
     DescribeTableRequest describeTableRequest;
     describeTableRequest.SetTableName(tableName);
     bool shouldContinue = true;
     DescribeTableOutcome outcome = dynamoDbClient->DescribeTable(describeTableRequest);

     while (shouldContinue)
     {
         if (outcome.GetResult().GetTable().GetTableStatus() == TableStatus::ACTIVE)
         {
            break;
         }
         else
         {
            std::this_thread::sleep_for(std::chrono::seconds(1));
         }
     }
     return true;
  }
  else if(createTableOutcome.GetError().GetErrorType() == DynamoDBErrors::RESOURCE_IN_USE)
  {
     return true;
  }

  return false;
}
```