C++函数式编程

1std::vector<int> count_lines_in_files(const std::vector<std::string> &files)
2{
3    reuturn files | transform(count_lines);
4}

1std::vector<double> xs = {1, 2, 3, 4, ...};
2auto result = sum(xs | transform(sqrt));

1filter: (collection<T>, (T → bool)) → collection<T>

1transform: (collection<In>, (In → Out)) → collection<Out>

1double average_score(const std::vector<int> &scores)
2{
3    int sum = 0;
4    for (int score: scores) {
5        sum += score;
6    }
7    return sum / (double) scores.size();
8}

1double average_score(const std::vector<int> &scores)
2{
3    return std::accumulate(scores.cbegin(), scores.cend(), 0) /
4           (double) scores.size();
5}

1double average_score(const std::vector<int>& scores)
2{
3    return std::reduce(
4            std::execution::par,
5            scores.cbegin(), scores.cend(),
6            0
7    ) / (double) scores.size();
8}

error: #error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported.

 1int f(int previous_count, char c)
 2{
 3    return (c != '\n') ? previous_count
 4                       : previous_count + 1;
 5}
 6
 7int count_lines(const std::string & s)
 8{
 9    return std::accumulate(
10        s.cbegin(), s.cend(),
11        0,
12        f
13    );
14}

 1bool is_not_space(char c)
 2{
 3    return c != ' ';
 4}
 5
 6std::string trim_left(std::string s)
 7{
 8    s.erase(s.begin(),
 9            std::find_if(s.begin(), s.end(), is_not_space));
10    return s;
11}
12
13std::string trim_right(std::string s)
14{
15    s.erase(std::find_if(s.rbegin(), s.rend(), is_not_space).base(),
16            s.end());
17    return s;
18}
19
20std::string trim(std::string s)
21{
22    return trim_left(trim_right(std::move(s)));
23}

1std::partition(
2    people.begin(), people.end(),
3    is_female
4);

1people.erase(
2    std::remove_if(people.begin(), people.end(),
3                   is_not_female),
4    people.end());

1std::vector<person_t> females;
2
3std::copy_if(people.cbegin(), people.cend(),
4             std::back_inserter(females),
5             is_female);

 1template<class InputIt, class OutputIt, class UnaryPredicate>
 2OutputIt copy_if(InputIt first, InputIt last,
 3                 OutputIt d_first, UnaryPredicate pred)
 4{
 5    while (first != last) {
 6        if (pred(*first))
 7            *d_first++ = *first;
 8        first++;
 9    }
10    return d_first;
11}

1std::ostream_iterator<int>(std::cout, " ")

1std::vector<std::string> names;
2
3for (const auto &person : people) {
4    if (is_female(person)) {
5        names.push_back(name(person));
6    }
7}

1filter      : (collection<T>, (T -> bool)) -> collection<T>
2transform   : (collection<T>, (T -> T2)) -> collection<T2>

1std::vector<std::string> names;
2transform(filter(people, is_female), name);

 1std::vector<person_t> separated(people.size());
 2
 3const auto last = std::copy_if(
 4    people.cbegin(), people.cend(),
 5    separated.begin(),
 6    is_female);
 7
 8std::copy_if(
 9    people.cbegin(), people.cend(),
10    last,
11    is_not_female);

1template <typename FilterFunction>
2std::vector<std::string> names_for(
3    const std::vector<person_t> &people,
4    FilterFunction filter);

 1template <typename FilterFunction>
 2std::vector<std::string> names_for(
 3    const std::vector<person_t> &people,
 4    FilterFunction filter)
 5{
 6    std::vector<std::string> result;
 7
 8    for (const person_t &person : people) {
 9        if (filter(person)) {
10            result.push_back(name(person));
11        }
12    }
13
14    return result;
15}

 1template <typename FilterFunction>
 2std::vector<std::string> names_for(
 3    const std::vector<person_t>& people,
 4    FilterFunction filter)
 5{
 6    if (people.empty()) {
 7        return {};
 8    } else {
 9        const auto head = people.front();
10        const auto processed_tail = names_for(
11                tail(people),
12                filter);
13        if (filter(head)) {
14            return prepend(name(head), processed_tail);
15        } else {
16            return processed_tail;
17        }
18    }
19}

 1template <typename FIlterFunction, typename Iterator>
 2std::vector<std::string> names_for(
 3    Iterator people_begin,
 4    Iterator people_end,
 5    FilterFunction filter)
 6{
 7    ...
 8    const auto processed_tail = names_for(
 9        people_begin + 1,
10        people_end,
11        filter);
12    ...
13}

 1template <typename FilterFunction, typename Iterator>
 2std::vector<std::string> names_for_helper(
 3    Iterator people_begin,
 4    Iterator people_end,
 5    FilterFunction filter,
 6    std::vector<std::string> previously_collected)
 7{
 8    if (people_begin == people_end) {
 9        return previously_collected;
10    }
11    const auto head = *people_begin;
12
13    if (filter(head)) {
14        previously_collected.push_back(name(head));
15    }
16
17    return names_for_helper(
18        people_begin + 1,
19        people_end,
20        filter,
21        std::move(previously_collected));
22}
23
24// 调用函数
25template <typename FilterFunction, typename Iterator>
26std::vector<std::string> names_for_helper(
27    Iterator people_begin,
28    Iterator people_end,
29    FilterFunction filter)
30{
31    names_for_helper(people_begin, people_end, filter, {});
32}

 1std::vector<std::string> append_name_if(
 2    std::vector<std::string> previously_collected,
 3    const person_t &person)
 4{
 5    if (filter(person)) {
 6        previously_collected.push_back(name(person));
 7    }
 8    return previously_collected;
 9}
10
11...
12
13return std::accumulate(
14    people.cbegin(),
15    people.cend(),
16    std::vector<std::string>{},
17    append_name_if);

 1template<class InputIt, class T, class BinaryOperation>
 2constexpr // since C++20
 3T accumulate(InputIt first, InputIt last, T init,
 4             BinaryOperation op)
 5{
 6    for (; first != last; ++first) {
 7        init = op(std::move(init), *first); // std::move since C++20
 8    }
 9    return init;
10}

1int max(int arg1, int arg2) { ... }
2auto max(int arg1, int arg2) -> int { ... }

1int answer = 42;
2auto ask1() { return answer; }
3const auto &ask2() { return answer; }

1template <typename Object, typename Function>
2decltype(auto) call_on_object(Object &&object, Function function)
3{
4    return function(std::forward<Object>(object));
5}

 1int ask() { return 42; }
 2
 3typedef decltype(ask) * function_ptr;
 4
 5class convertible_to_function_ptr {
 6public:
 7    operator function_ptr() const   //函数指针callable_object
 8    {
 9        return ask;
10    }
11};
12
13int main()
14{
15    auto ask_ptr = &ask;
16    std::cout << ask_ptr() << '\n'; //调用函数指针
17
18    auto ask_ref = ask;
19    std::cout << ask_ref() << '\n'; //调用函数引用
20
21    convertible_to_function_ptr ask_wrapper;
22    std::cout << ask_wrapper() << '\n'; // 对象转换成函数指针
23}

1class function_object {
2public:
3    return_type operator()(arguments) const
4    {
5        ...
6    }
7};

1bool older_than_42(const person_t& person)
2{
3    return person.age > 42;
4}
5std::count_if(persons.cbegin(), persons.cend(),
6              older_than_42);

 1class older_than
 2{
 3public:
 4    older_than(int limit) : m_limit(limit) {}
 5    bool operator() (const person_t &person) const
 6    {
 7        return person.age() > m_limit;
 8    }
 9
10private:
11    int m_limit;
12}
13
14older_than older_than_42(42);
15
16std::count_if(persons.cbegin(), persons.cend(),
17              older_than(42));

 1template<typename T>
 2class older_than {
 3public:
 4    older_than(int limit) :
 5            m_limit(limit) {}
 6    bool operator()(const T &object) const
 7    {
 8        return object.age() > m_limit;
 9    }
10private:
11    int m_limit;
12};
13
14std::count_if(persons.cbegin(), persons.cend(),
15              older_than<person_t>(42));
16std::count_if(cars.cbegin(), cars.cend(),
17              older_than<car_t>(5));
18std::count_if(projects.cbegin(), projects.cend(),
19              older_than<project_t>(42));

 1class older_than {
 2public:
 3    older_than(int limit) : m_limit(limit) {}
 4    template<typename T>
 5    bool operator()(T &&object) const
 6    {
 7        return std::forward<T(object).age() > m_limit;
 8    }
 9};
10
11older_than predicate(5);
12std::count_if(persons.cbegin(), persons.cend(), predicate);
13std::count_if(cars.cbegin(), cars.cend(), predicate);
14std::count_if(projects.cbegin(), projects.cend(), predicate);

1std::copy_if(people.cbegin(), people.cend(),
2             std::back_inserter(females),
3             [](const person_t& person) {
4                 return person.gender() == person_t::female;
5             }
6        );

1[a, &b] (int x, int y) { return a * x + b * y; }
2   头         变量                函数体

 1class company_t {
 2public:
 3    std::string team_name_for(const person_t &employee) const;
 4    int count_team_members(const std::string &team_name) const;
 5
 6private:
 7    std::vector<person_t> m_employees;
 8    ...
 9};
10
11int company_t::count_team_members(const std::string &team_name) const
12{
13    return std::count_if(
14            m_employees.cbegin(), m_employees.cend(),
15            [this, &team_name](const person_t &employee) {
16                return team_name_for(employee) == team_name;
17            }
18        );
19}

1int count = 0;
2std::vector<std::string> words{"An", "ancient", "pond"};

 1std::unique_ptr<sesson_t> session = create_sesson();
 2auto request = server.request("GET /", session->id());
 3request.on_complete(
 4            [session]
 5            (response_t response)
 6            {
 7                std::cout << "Got response: " << response
 8                          << " for session: " << session;
 9            }
10        );

 1request.on_complete(
 2            [ session = std::move(session),
 3              time = current_time()
 4            ]
 5            (response_t response)
 6            {
 7                std::cout << "Got response: " << response
 8                          << " for session: " << session
 9                          << " the request took: "
10                          << (current_time() - time)
11                          << "milliseconds";
12            }
13        );

 1auto predicate = [limit = 42] (auto &&object) {
 2    return object.age() > limit;
 3}
 4
 5std::count_if(persons.cbegin(), persons.cend(),
 6              predicate);
 7std::count_if(cars.cbegin(), cars.cend(),
 8              predicate);
 9std::count_if(projects.cbegin(), projects.cend(),
10              predicate);

1[] (auto first, decltype(first) second) { … }

1[] <typename T> (T first, T second) { … }

1ok_response = filter(response,
2        [] (const response_t &response) {
3            return !response.error();
4        });
5
6failed_response = filter(response,
7        [] (const response_t &response) {
8            return response.error();
9        });

1ok_response = filter(response, not_error);
2// 或者        filter(response, !error);
3// 或者        filter(response, error == false);
4
5failed_response = filter(response, error);
6// 或者            filter(response, not_error == false);
7// 或者            filter(response, error == true);

 1class error_test_t {
 2public:
 3    error_test_t(bool error = true) : m_error(error) {}
 4    template <typename T>
 5    bool operator()(T &&value) const
 6    {
 7        return m_error == (bool) std::forward<T>(value).error();
 8    }
 9
10private:
11    bool m_error;
12};
13
14error_test_t error(true);
15error_test_t not_error(false);

 1class error_test_t {
 2public:
 3    ...
 4    error_test_t operator==(bool test) const
 5    {
 6        return error_test_t(
 7            test ? m_error : !m_error
 8        );
 9    }
10
11    error_test_t operator!() const
12    {
13        return error_test_t(!m_error);
14    }
15};

1std::vector<int> numbers{1, 2, 3, 4};
2product = std::accumulate(numbers.cbegin(), numbers.cend(), 1,
3                          std::multiplies<int>());
4std::vector<int> numbers{5, 21, 13, 42};
5std::sort(numbers.begin(), numbers.end(), std::greater<int>());
6// numbers now contain {42, 21, 13, 5}

 1// 算术操作
 2std::plus
 3std::minus
 4std::multiplies
 5std::divides
 6std::modulus    // %
 7std::negates    // -a
 8
 9// 比较操作
10std::equal_to
11std::not_equal_to
12std::greater
13std::less
14std::greater_equal
15std::less_equal
16
17// 逻辑操作
18std::logical_and
19std::logical_or
20std::logical_not
21
22// 位操作
23std::bit_and
24std::bit_or
25std::bit_xor

1using namespace boost::phoenix::arg_names;
2std::vector<int> numbers{21, 5, 62, 42, 53};
3std::partition(numbers.begin(), numbers.end(),
4               arg1 <= 42);
5// numbers now contain {21, 5, 42, 62, 53}
6//                         <= 42    > 42

1std::accumulate(numbers.cbegin(), numbers.cend(), 0,
2                arg1 + arg2 * arg2 / 2);

1product = std::accumulate(numbers.cbegin(), numbers.cend(), 1,
2                          arg1 * arg2);
3std::sort(numbers.begin(), numbers.end(), arg1 > arg2);

1std::function<float (float, float)> test_function;
2test_function = std::fmaxf;                     // 函数
3test_function = std::multiplies<float>();       // 类的调用函数
4test_function = std::multiplies<>();            // 类通用调用函数
5test_function = [x] (float a, float b) { return a * x + b; };   // lambda表达式
6test_function = [x] (auto a, auto b) { return a * x + b; };     // 通用lanbda表达式
7test_function = (arg1 + arg2) / 2;              // boost.phoenix 表达式
8test_function = [](std::string s) { return s.empty(); } // 错误

1std::function<void()> bound_f = std::bind(f, n1, std::ref(n2), std::cref(n3));

 1class greater_than {
 2public:
 3    greater_than(int value) : m_value {}
 4    bool operator()(int arg) const
 5    {
 6        return arg > m_value;
 7    }
 8private:
 9    int m_value;
10};
11...
12
13greater_than greater_than_42(42);
14greater_than_42(1);     // false
15greater_than_42(50);    // true
16
17std::partition(xs.begin(), xs.end(), greater_than(6));

 1template<typename Function, typename SecondArgType>
 2class partial_application_on_2nd_impl {
 3public:
 4    partial_application_on_2nd_impl(Function function,
 5                                    SecondArgType second_arg)
 6        : m_function(function)
 7        , m_value(second_arg)
 8    {}
 9
10    template<typename FirstArgType>
11    auto operator()(FirstArgType &&first_arg) const
12        -> decltype(m_function(
13                std::forward<FirstArgType>(first_arg),
14                m_second_arg))
15    {
16        return m_function(
17                std::forward<FirstArgType>(first_arg),
18                m_second_arg);
19    }
20
21    ...
22private:
23    Function m_function;
24    SecondArgType m_second_arg;
25};
26
27// 绑定函数
28template<typename Function, typename SecondArgType>
29partial_application_bind2nd_impl<Function, SecondArgType>
30bind2nd(Function &&function, SecondArgType &&second_arg)
31{
32    return partial_application_bind2nd_impl<Function, SecondArgType>(
33            std::forward<Function>(function),
34            std::forward<SecondArgType>(second_arg));
35}
36
37auto greater_than_42 = bind2nd(std::greater<int>(), 42);
38
39greater_than_42(1);     // false
40greater_than_42(50);    // true

1// 把角度转换成弧度
2std::vector<double> degrees = {0, 30, 45, 60};
3std::vector<double> radians(degrees.size());
4
5std::transform(degrees.cbegin(), degrees.cend(),
6               radians.begin(),
7               bind2nd(std::multiplies<double>, PI / 180));

1auto bound = std::bind(std::greater<double>(), _1, 42);
2bool is_6_greater_than_42 = bound(6);

1auto is_greater_than_42 =
2    std::bind(std::greater<double>(), _1, 42);
3auto is_less_than_42 =
4    std::bind(std::greater<double>(), 42, _1);

1std::sort(scores.begin(), scores.end(),
2          std::bind(std::greater<double>, _2, _1));

 1enum output_format_t
 2{
 3    name_only,
 4    full_name,
 5};
 6
 7void print_person(const person_t &person,
 8                  std::ostream &out,
 9                  person_t::output_format_t format);
10
11std::for_each(people.cbegin(), people.cend(),
12        std::bind(print_person,
13                  _1,
14                  std::ref(std::cout),
15                  person_t::name_only
16            ));

 1class person_t {
 2public:
 3    ...
 4    void print(std::ostream &out, person_t::output_format_t format);
 5}
 6
 7std::for_each(people.cbegin(), people.cend(),
 8        std::bind(&person_t::print,
 9                 _1,
10                 std::ref(std::cout),
11                 person_t::name_only
12            ));

1auto is_greater_than_42 =
2    [] (double value) {
3        return std::greater<double>()(value, 42);
4    };
5
6auto is_less_than_42 =
7    [] (double value) {
8        return std::greater<double>()(42, value);
9    };

1std::sort(scores.begin(), scores.end(),
2          [] (double value1, double value2) {
3              return std::greater<double>()(value2, value1);
4          });

 1std::for_each(people.cbegin(), people.cend(),
 2              [] (const person_t &person) {
 3                  print_person(person,
 4                               std::cout,
 5                               person_t::name_only);
 6              });
 7std::for_each(people.cbegin(), people.cend(),
 8              [&file] (const person_t &person) {
 9                  print_person(person,
10                               file,
11                               person_t::name_only);
12              });

1// 正常版本的调用
2int result = f0(10, 2);
3
4// Currying版本的调用
5auto f1 = f0(10);
6int f2 = f1(2);

 1// greater : (double, double) -> bool
 2bool greater(double first, double second)
 3{
 4    return first > second;
 5}
 6
 7// greater_curried : double → (double → bool)
 8auto greater_curried(double first)
 9{
10    return [first] (double second) {
11        return first > second;
12    }
13}
14
15greater(2, 3);          // false
16greater_curried(2);     // 返回函数对象
17greater_curried(2)(3);  // false

1auto print_person_cd(const person_t &person)
2{
3    return [&] (std::ostream &out) {
4        return [&] (person_t::output_format_t format) {
5            print_person(person, out, format);
6        }
7    }
8}

 1using std::cout;
 2
 3auto print_person_cd = make_curried(print_person);
 4
 5// 所有的方式都可以调用
 6print_person_cd(martha, cout, person_t::full_name);
 7print_person_cd(martha)(cout, person_t::full_name);
 8print_person_cd(martha, cout)(person_t::full_name);
 9print_person_cd(martha)(cout)(person_t::full_name);
10
11auto print_martha = print_person_cd(martha);
12print_martha(cout, person_t::name_only);
13
14auto print_martha_to_cout = print_person_cd(martha, cout);
15print_martha_to_cout(person_t::name_only);

1result_t query(connection_t &connection,
2               session_t &session,
3               const std::string &table_name,
4               const std::string &filter);

 1auto table = "Movies";
 2auto filter = "Name = \"Sintel\"";
 3results = query(local_connection, session, table, filter);
 4auto local_query = query(local_connection);
 5auto remote_query = query(remote_connection);
 6results = local_query(session, table, filter);
 7auto main_query = query(local_connection, main_session);
 8results = main_query(table, filter);
 9auto movies_query = main_query(table);
10results = movies_query(filter);

1auto local_query = query(local_connection);
2auto local_query = std::bind(query, local_connection, _1, _2, _3);
3auto session_query = std::bind(query, _1, main_session, _2, _3);

1tr -cs A-Za-z '\n' |
2    tr A-Z a-z |
3    sort |
4    uniq -c |
5    sort -rn |
6    sed ${1}q

1template <typename C,
2          typename T = typename C::value_type>
3std::unodered_map<T, unsigned int> count_occurrences(const C &collection);

 1void print_common_words(const std::string& text)
 2{
 3    return print_pairs(
 4        sort_by_frequency(
 5            reverse_pairs(
 6                count_occurrences(
 7                    words(text)
 8                )
 9            )
10        )
11    );
12}

1void to_upper(std::string &string);

 1void pointer_to_upper(std::string* str)
 2{
 3    if (str) to_upper(*str);
 4}
 5
 6void vector_to_upper(std::vector<std::string>& strs)
 7{
 8    for (auto& str : strs) {
 9        to_upper(str);
10    }
11}
12
13void map_to_upper(std::map<int, std::string>& strs)
14{
15    for (auto& pair : strs) {
16        to_upper(pair.second);
17    }
18}

 1void to_upper(std::string &string);
 2
 3// 指针提升
 4template <typename Function>
 5auto pointer_lift(Function f)
 6{
 7    return [f] (auto *item) {
 8        if (item) {
 9            f(*item);
10        }
11    }
12}
13
14// 集合提升
15template <typename Function>
16auto collection_lift(Function f)
17{
18    return [f] (auto &items) {
19        for (auto &item : items) {
20            f(item);
21        }
22    };
23}
24
25// 例子
26std::string str{"lift"};
27std::string *pstr = new std::string{"lift"};
28std::vector<std::string> vstr{"lift", "function"};
29to_upper(str);
30pointer_lift(to_upper)(pstr);
31collection_lift(to_upper)(vstr);

 1template <typename C,
 2          typename P1 = typename std::remove_cv<
 3                typename C::value_type::first_type>::type,
 4          typename P2 = typename C::value_type::second_type
 5          >
 6std::vector<std::pair<P2, P1>> reverse_pairs(const C &items)
 7{
 8    std::vector<std::pair<P2, P1>> result(item.size());
 9    std::transform(
10        std::begin(items), std::end(items),
11        std::begin(result),
12        [] (const std::pair<const P1, P2> &p) {
13            return std::make_pair(p.second, p.first);
14        }
15    );
16    return result;
17}

 1// 电影类
 2class movie_t {
 3public:
 4    double average_score() const;
 5    ...
 6
 7private:
 8    std::string name;
 9    std::list<int> scores;
10};
11
12// 计算平均评分的方法
13double movie_t::average_score() const
14{
15    return std::accumulate(scores.begin(),
16                           scores.end(), 0)
17            / (double) scores.size();
18}

 1class movie_t {
 2public:
 3    double average_score() const;
 4    ...
 5
 6private:
 7    std::string name;
 8    std::list<int> scores;
 9    size_t scores_size;
10};

 1// 全局变量G
 2int G = 10;
 3
 4// 引用透明
 5int pulsOne(int x)
 6{
 7    return x + 1;
 8}
 9
10// 非引用透明
11int plusG(int x)
12{
13    return x + G;
14}

 1double max(const std::vector<double> &numbers)
 2{
 3    assert(!numbers.empty());
 4    auto result = std::max_element(numbers.cbegin(),
 5                                   numbers.cend());
 6    std::cerr << "Maximum is: " << *result << std::endl;
 7    return *result;
 8}
 9
10int main()
11{
12    auto sum_max =
13        max({1}) +
14        max({1, 2}) +
15        max({1, 2, 3});
16
17    std::cout << sum_max << std::endl;
18}

1int main()
2{
3    auto sum_max =
4        1 +
5        2 +
6        3;
7    std::cout << sum_max << std::endl;
8}

1while (1) {
2    - 绘制迷宫和玩家
3    - 读取用户输入
4    - 是否可以移动（按下方向箭头键）检查目的地单元是否是墙，不是墙则移动到目的地
5    - 检查是否到达退出点，到达则显示消息，退出循环
6}

 1position_t next_position(
 2            direction_t direction,
 3            const position_t &previous_position,
 4            const maze_t &maze)
 5{
 6    const position_t desired_position{previous_position, direction};
 7    return maze.is_wall(desired_position) ? previous_postion
 8                                          : desired_position;
 9}
10
11position_t::position_t(const position_t &original,
12                       direction_t direction)
13    : x { direction == Left  ? original.x - 1 :
14          direction == Right ? original.x + 1 :
15                               original.x     }
16    , y { direction == Up    ? original.y + 1 :
17          direction == Down  ? original.y - 1 :
18                               original.y     }
19{}

 1void process_events(const maze_t &maze,
 2                    const position_t &current_position)
 3{
 4    if (maze.is_exit(current_position)) {
 5        return;
 6    }
 7
 8    const direction_t direction = ...;
 9    draw_maze();
10    draw_player(current_position, direction);
11    const auto new_position = next_position(direction,
12                                            current_position,
13                                            maze);
14    process_events(maze, new_position);
15}
16
17int main()
18{
19    const maze_t maze("maze.data");
20    process_events(maze, maze.start_position());
21}

 1void client_disconnected(const client_t &client)
 2{
 3    // 释放客户端资源
 4    ...
 5    // 减少连接数目
 6    connected_clients--;
 7    if (connected_clients == 0) {
 8        // 省电模式
 9    }
10}

1const std::string name{"John Smith"};
2std::string name_copy            = name;    // 拷贝
3std::string &name_ref            = name;    // 可改变引用，错误
4const std::string &name_constref = name;    // 不可改变引用
5std::string *name_ptr            = &name;   // 可改变指针，错误
6const std::string *name_constptr = &name;   // 不可改变指针

 1class person_t
 2{
 3public:
 4    std::string name() { return m_name; }
 5    std::string name_const() const { return m_name; }
 6
 7private:
 8    std::string m_name;
 9};
10
11person_t person;
12const auto &p = person;
13std::string name = p.name();       // 错误
14std::string name = p.name_const(); // 正确

1class person_t
2{
3public:
4    const std::string name;
5    const std::string surname;
6    ...
7};