As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usando o AWS SDK para C\$1\$1
<a name="programming-general"></a>

Esta seção fornece informações sobre o uso geral do AWS SDK para C\$1\$1, além do que é abordado em [Introdução ao uso do AWS SDK para C\$1\$1](getting-started.md).

Para ver exemplos de programação específica de serviços, consulte [Exemplos de código do AWS SDK para C\$1\$1](programming-services.md).

**Topics**
+ [Iniciar e encerrar o SDK](basic-use.md)
+ [Fazer solicitações de AWS service (Serviço da AWS)](using-service-client.md)
+ [Programação assíncrona](async-methods.md)
+ [Módulos de utilidade](utility-modules.md)
+ [Gerenciamento de memória](memory-management.md)
+ [Tratamento de erros](error-handling.md)

# Iniciar e encerrar o AWS SDK para C\$1\$1
<a name="basic-use"></a>

As aplicações que usam o AWS SDK para C\$1\$1 devem inicializá-lo. Da mesma forma, antes de encerrar a aplicação, encerre o SDK. As duas operações aceitam opções de configuração que afetam os processos de inicialização e encerramento e as chamadas subsequentes para o SDK.

Todas as aplicações que usam o AWS SDK para C\$1\$1 devem incluir o arquivo `aws/core/Aws.h`.

É necessário inicializar o AWS SDK para C\$1\$1 por meio de uma chamada de `Aws::InitAPI`. Antes de encerrar a aplicação, encerre o SDK chamando `Aws::ShutdownAPI`. Cada método aceita um argumento de [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). Todas as outras chamadas para o SDK podem ser realizadas entre essas duas chamadas de método.

**Todas as chamadas ao AWS SDK para C\$1\$1 realizadas entre `Aws::InitAPI` e `Aws::ShutdownAPI` devem estar contidas em um par de chaves curvas ou devem ser invocadas por funções chamadas entre os dois métodos.**

Uma aplicação básica de esqueleto é mostrada abaixo.

```
#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;
}
```

**O SDK para C\$1\$1 e as respectivas dependências usam objetos estáticos em C\$1\$1, e a ordem da destruição de objetos estáticos não é determinada pelo padrão C\$1\$1. Para evitar problemas de memória causados pela ordem não determinística da destruição de variáveis estáticas, não agrupe as chamadas de `Aws::InitAPI` e `Aws::ShutdownAPI` em outro objeto estático.**

# Fazer solicitações de AWS service (Serviço da AWS) usando AWS SDK para C\$1\$1
<a name="using-service-client"></a>

 Para acessar programaticamente os Serviços da AWS, os SDKs usam uma classe de cliente para cada AWS service (Serviço da AWS). Se seu aplicativo precisar acessar o Amazon EC2, por exemplo, seu aplicativo criará um objeto cliente do Amazon EC2 para interagir com esse serviço. Em seguida, você usa o cliente de serviço para fazer solicitações para esse AWS service (Serviço da AWS). 

Para fazer uma solicitação a um AWS service (Serviço da AWS), primeiro você cria e [configure](configuring.md) um cliente de serviço. Para cada AWS service (Serviço da AWS) utilizado pelo seu código, ele tem sua própria biblioteca e tipo dedicado para interagir com ele. O cliente expõe um método para cada operação de API exposta pelo serviço. 

O namespace de uma classe de cliente segue a convenção `Aws::Service::ServiceClient`. Por exemplo, a classe de cliente para AWS Identity and Access Management (IAM) é `Aws::IAM::IAMClient` e a classe de cliente do Amazon S3 é `Aws::S3::S3Client`.

Todas as classes de cliente de todos os serviços da AWS são seguras para encadeamento.

Ao instanciar uma classe de cliente, as credenciais da AWS devem ser fornecidas. As credenciais podem ser fornecidas por meio do seu código, do ambiente ou do arquivo compartilhado `config` da AWS e do arquivo compartilhado `credentials`. Para acessar mais informações sobre credenciais, consulte [as instruções para configurar a autenticação recomendada do Centro de Identidade do IAM](credentials.md) ou use [outro provedor de credenciais disponível](credproviders.md).

# Programação assíncrona usando o AWS SDK para C\$1\$1
<a name="async-methods"></a>

## Métodos assíncronos do SDK
<a name="asynchronous-sdk-methods"></a>

Para muitos métodos, o SDK para C\$1\$1 fornece versões síncronas e assíncronas. Um método é assíncrono se inclui o sufixo `Async` em seu nome. Por exemplo, o método `PutObject` do Amazon S3 é síncrono, enquanto `PutObjectAsync` é assíncrono.

Como todas as operações assíncronas, um método do SDK assíncrono retorna antes que sua tarefa principal seja concluída. Por exemplo, o método `PutObjectAsync` retorna antes de concluir o upload do arquivo no bucket do Amazon S3. Enquanto a operação de upload continua, a aplicação pode realizar outras operações, inclusive chamar outros métodos assíncronos. A aplicação é notificada de que uma operação assíncrona foi concluída quando uma função de retorno de chamada associada é invocada.

As seções a seguir descrevem um exemplo de código que demonstra a chamada do método assíncrono `PutObjectAsync`. Cada seção se concentra em partes individuais de [todo o arquivo de origem](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_async.cpp) do exemplo.

## Chamar métodos assíncronos do SDK
<a name="calling-sdk-asynchronous-methods"></a>

Em geral, a versão assíncrona de um método do SDK aceita os argumentos a seguir.
+ Uma referência ao mesmo objeto do tipo Solicitação que sua contraparte síncrona.
+ Uma referência a uma função de retorno de chamada do manipulador de respostas. Essa função de retorno de chamada é invocada quando a operação assíncrona é concluída. Um dos argumentos contém o resultado da operação.
+ Um `shared_ptr` opcional para um objeto `AsyncCallerContext`. O objeto é transmitido para o retorno de chamada do manipulador de respostas. Ele inclui uma propriedade UUID que pode ser usada para transmitir informações de texto para o retorno de chamada.

O método `uploadFileAsync` mostrado abaixo configura e chama o método `PutObjectAsync` do Amazon S3 do SDK para fazer upload de forma assíncrona de um arquivo para um bucket do Amazon S3.

A função recebe referências aos seguintes objetos: `S3Client` e `PutObjectRequest`. Ela as recebe da função principal porque precisamos garantir que esses objetos existam durante toda a duração das chamadas assíncronas.

A `shared_ptr` para um objeto `AsyncCallerContext` é alocada. Sua propriedade `UUID` é definida como o nome do objeto do Amazon S3. Para fins de demonstração, o retorno de chamada do manipulador de resposta acessa a propriedade e gera o respectivo valor.

A chamada para `PutObjectAsync` inclui um argumento de referência para a função de retorno de chamada do manipulador `uploadFileAsyncFinished` de respostas. Essa função de retorno de chamada é examinada em mais detalhes na próxima seção.

```
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;
}
```

Os recursos para uma operação assíncrona devem existir até que a operação seja concluída. Por exemplo, os objetos de cliente e de solicitação devem existir até que a aplicação receba a notificação de que a operação foi concluída. A aplicação em si não pode ser encerrada até que a operação assíncrona seja concluída.

Por esse motivo, o método `uploadFileAsync` aceita referências a objetos `S3Client` e `PutObjectRequest` em vez de criá-los no método `uploadFileAsync` e armazená-los em uma variável local. 

No exemplo, o método `PutObjectAsync` retorna para o chamador imediatamente após o início da operação assíncrona, permitindo que a cadeia de chamadas realize tarefas adicionais enquanto a operação de upload está em andamento. 

Se o cliente fosse armazenado em uma variável local no método `uploadFileAsync`, ele sairia do escopo quando o método retornasse. No entanto, o objeto de cliente deve continuar existindo até que a operação assíncrona seja concluída.

## Notificação da conclusão de uma operação assíncrona
<a name="notification-of-the-completion-of-an-asynchronous-operation"></a>

Quando uma operação assíncrona é concluída, uma função de retorno de chamada do manipulador de respostas da aplicação é invocada. Essa notificação inclui o resultado da operação. O resultado está contido na mesma classe do tipo Outcome retornada pela contraparte síncrona do método. No exemplo de código, o resultado está em um objeto `PutObjectOutcome`.

A função de retorno de chamada do manipulador de respostas do exemplo `uploadFileAsyncFinished` é mostrada abaixo. Ela confere se a operação assíncrona foi bem-sucedida ou falhou. Ela usa uma `std::condition_variable` para notificar o encadeamento da aplicação de que a operação assíncrona foi concluída.

```
// 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();
}
```

Com a operação assíncrona concluída, os recursos associados a ela podem ser liberados. Se desejar, você também poderá encerrar a aplicação.

O código a seguir demonstra como os métodos `uploadFileAsync` e `uploadFileAsyncFinished` são usados por uma aplicação.

A aplicação aloca os objetos `S3Client` e `PutObjectRequest` para que eles continuem existindo até que a operação assíncrona seja concluída. Após a chamada de `uploadFileAsync`, a aplicação pode realizar as operações que desejar. Para simplificar, o exemplo usa um `std::mutex` e uma `std::condition_variable` para esperar até que o retorno de chamada do manipulador de respostas o notifique de que a operação de upload foi concluída.

```
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;
}
```

Veja o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/s3/put_object_async.cpp).

# Módulos utilitários disponíveis no AWS SDK para C\$1\$1
<a name="utility-modules"></a>

O AWS SDK para C\$1\$1 inclui muitos [módulos utilitários](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/aws-cpp-sdk-core/html/namespace_aws_1_1_utils.html) para reduzir a complexidade do desenvolvimento de aplicações da AWS em C\$1\$1.

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

Uma pilha HTTP que fornece agrupamento de conexões é segura para encadeamento e pode ser reutilizada conforme necessário. Para acessar mais informações, consulte [Configuração do cliente da AWS](client-config.md).


****  

|  |  | 
| --- |--- |
|  Cabeçalhos  |   [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)   | 
|  Documentação de 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)   | 

## Utilitários de string
<a name="string-utils"></a>

Funções principais de string, como `trim`, `lowercase` e conversões numéricas.


****  

|  |  | 
| --- |--- |
|  Cabeçalho  |   [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)   | 
|  Documentação de 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ários de hashing
<a name="hashing-utils"></a>

Funções de hashing, como `SHA256`, `MD5`, `Base64` e `SHA256_HMAC`.


****  

|  |  | 
| --- |--- |
|  Cabeçalho  |   [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)   | 
|  Documentação de 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)   | 

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

Um analisador JSON totalmente funcional e leve (um invólucro mínimo ao redor de *`cJSON`*).


****  

|  |  | 
| --- |--- |
|  Cabeçalho  |   [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)   | 
|  Documentação de 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)   | 

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

Um analisador XML leve (um invólucro mínimo ao redor de *`tinyxml2`*). O [padrão RAII](http://en.cppreference.com/w/cpp/language/raii) foi adicionado à interface.


****  

|  |  | 
| --- |--- |
|  Cabeçalho  |   [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)   | 
|  Documentação de 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)   | 

# Gerenciamento de memória no AWS SDK para C\$1\$1
<a name="memory-management"></a>

 AWS SDK para C\$1\$1 Fornece uma maneira de controlar a alocação e desalocação de memória em uma biblioteca.

**nota**  
O gerenciamento de memória personalizado estará disponível somente se você usar uma versão da biblioteca desenvolvida com a constante de tempo de compilação definida `USE_AWS_MEMORY_MANAGEMENT`.  
Se você usar uma versão da biblioteca desenvolvida sem a constante de tempo de compilação, as funções globais do sistema de memória, como `InitializeAWSMemorySystem`, não funcionarão; em vez disso, serão usadas as funções globais `new` e `delete`.

Para obter mais informações sobre a constante de tempo de compilação, consulte [STL e AWS Strings and](#stl-and-aws-strings-and-vectors) Vectors.

## Alocar e desalocar memória
<a name="allocating-and-deallocating-memory"></a>

 **Como alocar ou desalocar memória** 

1. Subclasse `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**  
É possível alterar a assinatura de tipo para `AllocateMemory` conforme necessário.

1. Use a estrutura `Aws::SDKOptions` para configurar o uso do gerenciador de memória personalizado. Transmita a instância da estrutura para `Aws::InitAPI`. Antes de encerrar a aplicação, encerre o SDK chamando `Aws::ShutdownAPI` com a mesma instância. 

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

## STL e AWS cadeias de caracteres e vetores
<a name="stl-and-aws-strings-and-vectors"></a>

Quando inicializado com um gerenciador de memória, o AWS SDK para C\$1\$1 adia toda alocação e desalocação para o gerenciador de memória. Caso não exista um gerenciador de memória, o SDK usa new e delete globais.

Se você usar alocadores STL personalizados, deverá alterar as assinaturas de tipo de todos os objetos STL a serem comparados à política de alocação. Como a STL é amplamente usada na implementação e na interface do SDK, uma única abordagem no SDK inibiria a transmissão direta de objetos STL padrão para o SDK ou o controle da alocação de STL. Como alternativa, uma abordagem híbrida, que é utilizar alocadores personalizados internamente e permitir objetos STL padrão e personalizados na interface, poderia dificultar a investigação de problemas de memória.

A solução é usar a constante de tempo de compilação do sistema de memória `USE_AWS_MEMORY_MANAGEMENT` para controlar quais tipos de STL são utilizados pelo SDK.

Se a constante de tempo de compilação estiver ativada (ativada), os tipos serão resolvidos para tipos STL com um alocador personalizado conectado ao sistema de memória. AWS 

Se a constante de tempo de compilação estiver desabilitada (desativada), todos os tipos `Aws::*` serão resolvidos para o tipo `std::*` padrão correspondente.

 **Exemplo de código do arquivo `AWSAllocator.h` no 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
```

No exemplo de código, o `AwsAllocator` pode ser um alocador personalizado ou padrão, dependendo da constante de tempo de compilação.

 **Exemplo de código do arquivo `AWSVector.h` no SDK** 

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

No exemplo de código, definimos os tipos `Aws::*`.

Se a constante de tempo de compilação estiver ativada (ativada), o tipo mapeia para um vetor usando a alocação de memória personalizada e o AWS sistema de memória.

Se a constante de tempo de compilação estiver desabilitada (desativada), o tipo será associado a um `std::vector` normal com parâmetros de tipo padrão.

A criação de alias é usada para todos os tipos `std::` no SDK que realizam alocação de memória, como contêineres, fluxos e buffers de strings. Eles AWS SDK para C\$1\$1 usam esses tipos.

## Problemas remanescentes
<a name="remaining-issues"></a>

É possível controlar a alocação de memória no SDK; no entanto, os tipos STL ainda dominam a interface pública por meio de parâmetros de string para os métodos `initialize` e `set` do objeto de modelo. Se você não usa STL, mas utiliza strings e contêineres, precisa criar muitos temporários sempre que quer fazer uma chamada de serviço.

Para remover a maioria dos temporários e da alocação quando você faz chamadas de serviço usando não STL, implementamos o seguinte:
+ Cada Init/Set função que recebe uma string tem uma sobrecarga que exige a. `const char*`
+ Cada Init/Set função que usa um contêiner (mapa/vetor) tem uma variante de adição que usa uma única entrada.
+ Cada Init/Set função que usa dados binários tem uma sobrecarga que leva um ponteiro para os dados e um `length` valor.
+ (Opcional) Toda Init/Set função que usa uma string tem uma sobrecarga que recebe um final diferente de zero `const char*` e um valor. `length`

## Desenvolvedores de SDK nativo e controles de memória
<a name="native-sdk-developers-and-memory-controls"></a>

Siga estas regras no código do SDK:
+ Não use `new` e `delete`; em vez disso, use `Aws::New<>` e `Aws::Delete<>`.
+ Não use `new[]` e `delete[]`; use `Aws::NewArray<>` e `Aws::DeleteArray<>`.
+ Não use `std::make_shared`; use`Aws::MakeShared`.
+ Use `Aws::UniquePtr` como ponteiros exclusivos para um único objeto. Use a função `Aws::MakeUnique` para criar o ponteiro exclusivo.
+ Use `Aws::UniqueArray` como ponteiros exclusivos para uma matriz de objetos. Use a função `Aws::MakeUniqueArray` para criar o ponteiro exclusivo.
+ Não use contêineres STL diretamente; use um dos typedefs `Aws::` ou adicione um typedef para o contêiner desejado. Por exemplo:

  ```
  Aws::Map<Aws::String, Aws::String> m_kvPairs;
  ```
+ Use `shared_ptr` para qualquer ponteiro externo transmitido e gerenciado pelo SDK. É necessário inicializar o ponteiro compartilhado com uma política de destruição alinhada à forma como o objeto foi alocado. Você pode usar um ponteiro cru se não houver expectativa de que o SDK limpe o ponteiro.

# Lidar com erros no AWS SDK para C\$1\$1
<a name="error-handling"></a>

O AWS SDK para C\$1\$1 não usa exceções; no entanto, você pode usar exceções em seu código. Cada cliente de serviço exibe um objeto de resultado que inclui o resultado e um código de erro.

 **Exemplo de tratamento de condições de erro** 

```
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;
}
```