Como se deve usar std :: optional?

Estou lendo a documentação std::experimental::optionale tenho uma boa idéia sobre o que faz, mas não entendo quando devo usá-lo ou como devo usá-lo. O site ainda não contém exemplos, o que me dificulta a compreensão do verdadeiro conceito desse objeto. Quando é std::optionaluma boa escolha para usar e como compensa o que não foi encontrado no Padrão anterior (C ++ 11).

O exemplo mais simples que consigo pensar:

std::optional<int> try_parse_int(std::string s)
{
    //try to parse an int from the given string,
    //and return "nothing" if you fail
}

A mesma coisa pode ser realizada com um argumento de referência (como na assinatura a seguir), mas o uso std::optionaltorna a assinatura e o uso mais agradáveis.

bool try_parse_int(std::string s, int& i);

Outra maneira de fazer isso é especialmente ruim :

int* try_parse_int(std::string s); //return nullptr if fail

Isso requer alocação dinâmica de memória, preocupação com propriedade etc. - sempre prefira uma das outras duas assinaturas acima.

Outro exemplo:

class Contact
{
    std::optional<std::string> home_phone;
    std::optional<std::string> work_phone;
    std::optional<std::string> mobile_phone;
};

É extremamente preferível ter algo como a std::unique_ptr<std::string>para cada número de telefone! std::optionalfornece a localização dos dados, o que é ótimo para o desempenho.

Outro exemplo:

template<typename Key, typename Value>
class Lookup
{
    std::optional<Value> get(Key key);
};

Se a pesquisa não tiver uma determinada chave, podemos simplesmente retornar "sem valor".

Eu posso usá-lo assim:

Lookup<std::string, std::string> location_lookup;
std::string location = location_lookup.get("waldo").value_or("unknown");

Outro exemplo:

std::vector<std::pair<std::string, double>> search(
    std::string query,
    std::optional<int> max_count,
    std::optional<double> min_match_score);

Isso faz muito mais sentido do que, digamos, ter quatro sobrecargas de função que usam todas as combinações possíveis de max_count(ou não) e min_match_score(ou não)!

Ele também elimina o maldito "passe -1para max_countse você não quiser um limite" ou "passe std::numeric_limits<double>::min()para min_match_scorese você não quiser uma pontuação mínima"!

Outro exemplo:

std::optional<int> find_in_string(std::string s, std::string query);

Se a string de consulta não estiver inserida s, desejo "não int" - não qualquer valor especial que alguém decida usar para esse fim (-1?).

Para exemplos adicionais, você pode consultar a boost::optional documentação . boost::optionale std::optionalserá basicamente idêntico em termos de comportamento e uso.

Um exemplo é citado em Novo artigo adotado: N3672, std :: opcional :

 optional<int> str2int(string);    // converts int to string if possible

int get_int_from_user()
{
     string s;

     for (;;) {
         cin >> s;
         optional<int> o = str2int(s); // 'o' may or may not contain an int
         if (o) {                      // does optional contain a value?
            return *o;                  // use the value
         }
     }
}

mas não entendo quando devo usá-lo ou como devo usá-lo.

Considere quando você está escrevendo uma API e deseja expressar que o valor "sem retorno" não é um erro. Por exemplo, você precisa ler dados de um soquete e, quando um bloco de dados estiver completo, analise-o e devolva-o:

class YourBlock { /* block header, format, whatever else */ };

std::optional<YourBlock> cache_and_get_block(
    some_socket_object& socket);

Se os dados anexados concluíram um bloco analisável, você pode processá-lo; caso contrário, continue lendo e anexando dados:

void your_client_code(some_socket_object& socket)
{
    char raw_data[1024]; // max 1024 bytes of raw data (for example)
    while(socket.read(raw_data, 1024))
    {
        if(auto block = cache_and_get_block(raw_data))
        {
            // process *block here
            // then return or break
        }
        // else [ no error; just keep reading and appending ]
    }
}

Editar: sobre o restante de suas perguntas:

Quando std :: optional é uma boa opção para usar

• Quando você calcula um valor e precisa devolvê-lo, torna-se melhor a semântica retornar por valor do que fazer referência a um valor de saída (que pode não ser gerado).

• Quando você deseja garantir que o código do cliente tenha que verificar o valor de saída (quem escreve o código do cliente pode não verificar se há erro - se você tentar usar um ponteiro não inicializado, receberá um dump principal; se você tentar usar um inicializado std :: opcional, você recebe uma exceção que pode ser capturada).

[...] e como isso compensa o que não foi encontrado na Norma anterior (C ++ 11).

Antes do C ++ 11, era necessário usar uma interface diferente para "funções que podem não retornar um valor" - retorne pelo ponteiro e verifique NULL ou aceite um parâmetro de saída e retorne um código de erro / resultado para "não disponível "

Ambos impõem um esforço extra e atenção do implementador do cliente para acertar e ambos são uma fonte de confusão (o primeiro leva o implementador do cliente a pensar em uma operação como uma alocação e exige que o código do cliente implemente a lógica de manipulação de ponteiros e o segundo permite código do cliente para evitar o uso de valores inválidos / não inicializados).

std::optional cuida bem dos problemas que surgem com as soluções anteriores.

Costumo usar opcionais para representar dados opcionais extraídos de arquivos de configuração, ou seja, onde esses dados (como com um elemento esperado, ainda que não necessário) em um documento XML) são fornecidos opcionalmente, para que eu possa mostrar de forma explícita e clara se os dados estavam realmente presentes no documento XML. Especialmente quando os dados podem ter um estado "não definido", versus um estado "vazio" e "definido" (lógica difusa). Com um opcional, definir e não definir é desobstruído, também vazio seria desobstruído com o valor de 0 ou nulo.

Isso pode mostrar como o valor de "não definido" não é equivalente a "vazio". Em conceito, um ponteiro para um int (int * p) pode mostrar isso, onde um nulo (p == 0) não está definido, um valor de 0 (* p == 0) está definido e vazio e qualquer outro valor (* p <> 0) está definido como um valor.

Para um exemplo prático, eu tenho uma parte da geometria extraída de um documento XML que tinha um valor chamado sinalizadores de renderização, onde a geometria pode substituir os sinalizadores de renderização (conjunto), desativar os sinalizadores de renderização (definido como 0) ou simplesmente não afetar os sinalizadores de renderização (não definidos), uma opção opcional seria uma maneira clara de representar isso.

Claramente, um ponteiro para um int, neste exemplo, pode atingir o objetivo, ou melhor, um ponteiro de compartilhamento, pois pode oferecer uma implementação mais limpa. Um nulo é sempre um "não definido"? Com um ponteiro, isso não é claro, pois nulo significa literalmente não alocado ou criado, embora possa , mas pode não necessariamente significar "não definido". Vale ressaltar que um ponteiro deve ser liberado e, em boas práticas, definido como 0, no entanto, como um ponteiro compartilhado, um opcional não requer limpeza explícita, portanto, não há uma preocupação de misturar a limpeza com o opcional não foi definido.

Eu acredito que é sobre clareza de código. A clareza reduz o custo de manutenção e desenvolvimento de código. Uma compreensão clara da intenção do código é incrivelmente valiosa.

O uso de um ponteiro para representar isso exigiria sobrecarregar o conceito de ponteiro. Para representar "nulo" como "não definido", normalmente você pode ver um ou mais comentários através do código para explicar essa intenção. Essa não é uma solução ruim em vez de opcional, no entanto, eu sempre opto pela implementação implícita, em vez de comentários explícitos, pois os comentários não são aplicáveis ​​(como na compilação). Exemplos desses itens implícitos para o desenvolvimento (os artigos em desenvolvimento que são fornecidos apenas para reforçar a intenção) incluem os vários lançamentos no estilo C ++, "const" (especialmente em funções-membro) e o tipo "bool", para citar alguns. Pode-se argumentar que você realmente não precisa desses recursos de código, desde que todos obedeçam a intenções ou comentários.