Capítulo Uno Introducción a la introducción de programación funcional funcional programación-

El primer capítulo presenta la programación funcional

La programación funcional es un paradigma de programación. En el que la función es un ciudadano de primera clase, puede ser pagado a la función de otras variables, puede ser utilizado como otros valores de retorno parámetro o función. requisitos de programación funcional, se utiliza sólo la expresión, no utilice comunicado.

La programación funcional es una programación declarativa y la programación imperativa diferente. Comando significa para comandar el equipo para hacer algo, tiene que realizar cada paso es claramente para calcular los resultados. Declaración significa que las instrucciones de qué hacer, entonces la tarea es averiguar cómo el lenguaje de programación que hacer, por lo general se define lo que es, en lugar de paso a paso para decirle a la computadora para hacerlo.

Entender los ejemplos de programación imperativos y declarativos

Imagínese, se escribe una función que recibe la lista de archivos y calcular el número de líneas por archivo.
enfoque imperativo podría tener este aspecto:

• Abrir cada archivo
• La definición de una variable para almacenar el número de filas que contar
• Cada vez que un carácter por carácter archivos leer, cuando se enfrentan a un salto de línea, cuente ++
• Para el final valor del archivo, el número de tiendas

Aquí está el código:

auto count_lines_in_file(const std::vector<std::string>& files) -> std::vector<int>
{
    std::vector<int> result;
    int c = 0;

    for (const auto& file : files)
    {
        int count_lines = 0;
        std::ifstream in(file);
        while (c = in.get())
        {
            if (c == '\n')
                count_lines++;
        }
        result.push_back(count_lines);
    }
    return result;
}

Sin embargo, el código anterior, propenso a errores, como las variables inicializadas, si, mientras que las condiciones y similares.
Los siguientes usos de aproximación std :: recuento algoritmo y flujos de entrada iteradores simplifica el código:

int count_lines(const std::string& file)
{
    std::ifstream in(file);
    // 像对容器一样，也可以对流迭代器使用stl算法
    return std::count(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>(), '\n');
}

auto count_lines_in_file(std::vector<std::string>& files) -> std::vector<int>
{
    std::vector<int> result;

    for (auto& file : files)
    {
        result.push_back(count_lines(file));
    }
}

En la solución anterior, no se preocupan de cómo se logra count_lines, count_lines simplemente señalando el número de filas del archivo. Se trata de las intenciones de programación funcional.

Vamos a simplificar el código de nuevo, más cerca de la programación funcional, esta vez utilizando std :: transformar:

auto coutn_lines_in_file3(std::vector<std::string>& files)
{
    std::vector<int> result;
    std::transform(files.begin(), files.end(), result.begin(), count_lines);
    return result;
}

Para C ++ 20, se puede simplificar el uso de la biblioteca de nuevo:

auto count_lines_in_file4(std::vector<std::string>& files)
{
    // 使用管道操作符(c++20)
    return files | std::transform(count_lines);
}