linguagem "C ++ 11/14 avançada biblioteca de impulso Programação Quest" no Capítulo 1, o novo C ++ (iii) registro de aprendizagem
1.7 Programação Funcional
A programação funcional é uma programação orientada para o processo, orientada a objectos e genérico programação de um paradigma de programação paralela, que se baseia no cálculo λ, o processo de cálculo como uma combinação de computação funções matemáticas.
1.7.1 expressão lambda
A forma básica:
[] (Params) {...}
[] Operador chamado lambda chumbo expressão, os parâmetros de função estão em parênteses, chaves é uma função do corpo demonstrações, qualquer C ++.
fechamentos tipo chamado expressões lambda, não posso escrever diretamente, muitas vezes é necessário utilizam memória auto tipo de função inferência. Exemplos são como se segue:
[root @ 192 C ++ 11] lambdademo.cpp # cat
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
F1 = Auto [] (int X)
{
return X * X;
}; // fim expressões, declarações devem terminar com um ponto e vírgula
auto f2 = [] (string s)
{
cout << "lambda:" << s << endl;
};
auto f3 = [] (int x, int y)
{
return x <y;
};
int main ()
{
cout << f1 (3) << endl;
F2 ( "lambda demonstração");
cout << f3 (1,5) << endl;
vector <int> v = {1,3,5,7};
for_each (v.begin (), v.end () [] (int x) {cout << x << "";});
for_each (v.begin (), v.end () [] (int & x) {se (x> 3) {x * = 2;}});
return 0;
}
[Raiz @ 192 C ++ 11] # g ++ lambdademo.cpp -o lambdademo -std = C ++ 11
1.7.2 Captura de variáveis externas
declaração completa sintaxe de expressão lambda é:
[Capturas] (params) mutable-> tipo {...}
captura a lista captura é chamado, você pode capturar as variáveis fora do alcance da expressão, o uso das funções que diretamente, o que é diferente da função comum ou uma função de um objeto no máximo.
Lista de captura captura pode ter várias entradas separadas por vírgulas, as regras são as seguintes:
[]: ,, não captura as funções que podem variáveis não o acesso de qualquer externos
[=]: Por valor (copiados) para capturar todas as variáveis externas, as funções que podem ser acessados, mas não modificados
[&]: Captura de Referência todas as variáveis externas, o corpo da função para acessar e modificar (para uma referência cuidadosa inválido)
[Var]: por valor (copiado) para capturar uma variável externa, as funções que podem ser acedidos, mas não modificado
[& Var]: referência capturar uma variável externa, o corpo da função de acesso e modificar
[Esta]: captura este ponteiro pode acessar as variáveis de membro de classe e funções membro
[=, & Var]: capturar um var variável de referência, o valor de outras variáveis externas capturado
[&, Var]: Captura de valor variável var, as referências a outras variáveis externas utilizadas para a captura
expressão lambda pode também ser modificada usando a palavra chave mutável, ser captada, o valor é adicionado a uma excepção, permitindo que as variáveis podem ser modificadas em função in vivo, mas isto só é copiado para dentro, sem a influência de variáveis externas, por exemplo:
[root @ 192 C ++ 11] lambda_multable_demo.cpp # cat
#include <iostream>
#include <algorithm>
using namespace std;
int main ()
{
int x = 0;
Auto F1 = [=] () {return o X mutável ++;}; // únicas modificações no interior, sem a influência de variáveis externas
F1 ();
cout << "multable X:" X << endl <<;
// Auto F2 = [=] () {return X ++;}; // erro de compilação, incremento de somente leitura 'X' variável
// F2 ();
// << COUT "valor x:" << x << endl;
auto F3 = [&] () {return ++ x;};
f3 ();
cout << "ref x:" << x << endl;
return 0;
}
[Raiz @ 192 C ++ 11] # g ++ lambda_multable_demo.cpp -o lambda_multable_demo -std = C ++ 11
[raiz @ 192 C ++ 11] # ./lambda_multable_demo
multable x: 0
ref x: 1
1.8 Programação Concorrente
Tópico armazenamento local se refere à variável ter mais de uma instância do processo, cada thread terá um totalmente independentes, tópicos de cópia localizadas, múltiplos tópicos para ler e variáveis escrever sem perturbar o outro, evitar completamente a competição, a sincronização de problemas , por exemplo:
[root @ 192 C ++ 11] # cat thread_local_demo.cpp
#include <iostream>
#include <algorithm>
#include <thread>
using namespace std;
int main ()
{
extern int x;
static int y = 0;
thread_local int z = 0;
f automático = [&] () {++ y; z ++; cout << << y "" << z << endl;};
t1 rosca (f);
enfiar t2 (f);
t1.join ();
t1.join ();
COUT << << Y "" Z << << endl;
retorno 0;
}
[a raiz 11 @ 192 C ++.] -o thread_local_demo thread_local_demo.cpp # L ++ - C ++ 11 -lpthread = STD.
[C ++ a raiz 11 @ 192.] # ./thread_local_demo
./thread_local_demo: /lib64/libstdc++.so.6: Versão GLIBCXX_3.4.22 ` 'não encontrado (exigido por ./thread_local_demo) / / no caso de glibc Redhat7.3 não atualizado não suporta funções de rosca, necessidade de atualizar a versão do trabalho glibc.
A saída actual é de 1,1 rosca t1 t2 fio real saída real de 2,1 a 2,0 a saída do segmento principal
ciclo de vida variável thread_local muito especial, que é configurado no inicio da rosca, no final do processo de destruição da linha, isto é, única rosca do ciclo de vida é eficaz.
thread_local aplicar apenas onde tópicos precisar de armazenamento isolado, quando você precisa de acesso a recursos compartilhados entre threads ainda precisa usar exclusão mútua e outros mecanismos de proteção.
1.9 programação orientada a segurança
1.9.1 nenhuma garantia de exceção
vazio func () noexcept {} // função determina nenhuma exceção é acionada
1,10 Várias
Em C ++ 98, na lista de parâmetros de modelo não pode ter dois consecutivos colchete angular direito >> ou o compilador irá interpretá-lo como um operador de deslocamento para a direita, o que resulta em uma gravação algum modelo de classe complexa, parâmetros do modelo deve ser separados por um espaço mais> final da lista, mas compensar essa falha em C ++ 11/14, o rosto >>, a prioridade será explicado em um comunicado na lista de parâmetros modelo modelo tag final.