К основному содержанию
скилл CX Codex

cpp-modern-features — скилл для Claude Code: C++ и установка

Скилл cpp-modern-features для Claude Code помогает применять возможности C++11–20: от вывода типов и лямбд до структурированных привязок. Помогает писать и менять код на современном C++.

Apache-2.0 246 установок ★ 201 обновлён 2026-09-08

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add TheBushidoCollective/han --skill cpp-modern-features -a claude-code
Открыть на GitHub

Что делает cpp-modern-features

Скилл даёт агенту примеры и пояснения по auto, лямбдам, циклам по диапазону и uniform initialization. Он также разбирает structured bindings из C++17 и инициализатор в цикле for из C++20. Можно попросить агента упростить итерацию по контейнеру или показать, как задать условие лямбдой.

Внутри есть фрагменты кода на C++ и пояснения к ним. Доступные инструменты включают чтение и изменение файлов, поиск по содержимому и запуск команд оболочки. Скилл не запускается отдельной слэш-командой: его инструкции подключаются к работе агента. Примеры охватывают разные версии стандарта, поэтому перед применением проверьте, какой стандарт C++ настроен в проекте.

Какие задачи решает

  • сократить запись сложных типов с помощью auto
  • перебирать контейнеры циклом по диапазону
  • написать лямбду для алгоритма или обратного вызова
  • инициализировать объекты фигурными скобками

Примеры запросов агенту

  • Покажи, как заменить тип итератора на auto в этом файле.
  • Перепиши обход контейнера на цикл по диапазону с const auto&.
  • Добавь лямбду, которая отбирает элементы по заданному порогу.

Как установить cpp-modern-features

1Через Skills CLI (Vercel)

npx skills add TheBushidoCollective/han --skill cpp-modern-features -a claude-code

2Вручную: положить файлы

~/.claude/skills/cpp-modern-features/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/cpp-modern-features/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о cpp-modern-features

Как установить cpp-modern-features в Claude Code?

Выполните npx skills add TheBushidoCollective/han --skill cpp-modern-features -a claude-code. Файл скилла находится по пути ~/.claude/skills/cpp-modern-features/SKILL.md.

Что делает cpp-modern-features?

Помогает агенту писать и разбирать код с возможностями современного C++: auto, лямбдами, циклами по диапазону и фигурной инициализацией.

Какие версии C++ охватывает cpp-modern-features?

Примеры охватывают возможности C++11, C++14, C++17 и C++20. Перед использованием проверьте стандарт, настроенный для проекта.

Исходный текст

SKILL.md · Apache-2.0
---
name: cpp-modern-features
user-invocable: false
description: Use when modern C++ features from C++11/14/17/20 including auto, lambdas, range-based loops, structured bindings, and concepts.
allowed-tools:
  - Read
  - Write
  - Edit
  - Grep
  - Glob
  - Bash
---

# Modern C++ Features

Modern C++ (C++11 and beyond) introduced significant improvements that make
C++ more expressive, safer, and easier to use. This skill covers essential
modern features including type inference, lambda expressions, range-based
loops, smart initialization, and the latest C++20 additions.

## Auto Type Inference

The `auto` keyword enables automatic type deduction, reducing verbosity while
maintaining type safety.

```cpp
#include <iostream>
#include <vector>
#include <map>
#include <string>

void auto_examples() {
    // Simple type inference
    auto x = 42;              // int
    auto pi = 3.14159;        // double
    auto name = "Alice";      // const char*
    auto message = std::string("Hello");  // std::string

    // Iterator simplification
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // Before C++11
    for (std::vector<int>::iterator it = numbers.begin();
         it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }

    // With auto
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }

    // Complex types
    std::map<std::string, std::vector<int>> data;
    auto it = data.find("key");  // Much cleaner than full type

    // Return type deduction (C++14)
    auto multiply = [](int a, int b) { return a * b; };

    // Structured bindings (C++17)
    std::map<std::string, int> scores = {{"Alice", 95}, {"Bob", 87}};
    for (const auto& [name, score] : scores) {
        std::cout << name << ": " << score << "\n";
    }
}
```

## Lambda Expressions

Lambdas provide inline anonymous functions, essential for modern C++
algorithms and callbacks.

```cpp
#include <algorithm>
#include <vector>
#include <functional>
#include <iostream>

void lambda_examples() {
    std::vector<int> numbers = {5, 2, 8, 1, 9, 3};

    // Basic lambda
    auto print = [](int n) { std::cout << n << " "; };
    std::for_each(numbers.begin(), numbers.end(), print);

    // Lambda with capture
    int threshold = 5;
    auto above_threshold = [threshold](int n) { return n > threshold; };

    // Capture by value [=]
    auto sum_above = [=]() {
        int sum = 0;
        for (int n : numbers) {
            if (n > threshold) sum += n;
        }
        return sum;
    };

    // Capture by reference [&]
    int count = 0;
    auto count_above = [&count, threshold](int n) {
        if (n > threshold) count++;
    };
    std::for_each(numbers.begin(), numbers.end(), count_above);

    // Generic lambda (C++14)
    auto generic_print = [](const auto& item) {
        std::cout << item << " ";
    };

    // Lambda as comparator
    std::sort(numbers.begin(), numbers.end(),
              [](int a, int b) { return a > b; });  // Descending

    // Mutable lambda
    auto counter = [count = 0]() mutable {
        return ++count;
    };

    std::cout << counter() << "\n";  // 1
    std::cout << counter() << "\n";  // 2
}

// Returning lambdas
std::function<int(int)> make_multiplier(int factor) {
    return [factor](int n) { return n * factor; };
}
```

## Range-Based For Loops

Range-based for loops provide clean, safe iteration over containers and
ranges.

```cpp
#include <vector>
#include <map>
#include <string>
#include <iostream>

void range_based_loops() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // Basic iteration
    for (int n : numbers) {
        std::cout << n << " ";
    }

    // By reference (for modification)
    for (int& n : numbers) {
        n *= 2;
    }

    // By const reference (efficient for large objects)
    std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
    for (const auto& name : names) {
        std::cout << name << "\n";
    }

    // With structured bindings (C++17)
    std::map<std::string, int> ages = {
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35}
    };

    for (const auto& [name, age] : ages) {
        std::cout << name << " is " << age << " years old\n";
    }

    // Initializer in for loop (C++20)
    for (std::vector<int> temp = {1, 2, 3}; auto n : temp) {
        std::cout << n << " ";
    }
}

// Custom range support
class Range {
    int start_, end_;

public:
    Range(int start, int end) : start_(start), end_(end) {}

    struct Iterator {
        int current;
        Iterator(int val) : current(val) {}
        int operator*() const { return current; }
        Iterator& operator++() { ++current; return *this; }
        bool operator!=(const Iterator& other) const {
            return current != other.current;
        }
    };

    Iterator begin() const { return Iterator(start_); }
    Iterator end() const { return Iterator(end_); }
};

void use_custom_range() {
    for (int i : Range(0, 10)) {
        std::cout << i << " ";
    }
}
```

## Uniform Initialization

Uniform initialization using braces provides consistent syntax and prevents
narrowing conversions.

```cpp
#include <vector>
#include <string>
#include <map>

struct Point {
    int x, y;
};

void uniform_initialization() {
    // Built-in types
    int a{42};
    double pi{3.14159};

    // Containers
    std::vector<int> numbers{1, 2, 3, 4, 5};
    std::map<std::string, int> ages{
        {"Alice", 30},
        {"Bob", 25}
    };

    // Aggregates
    Point p{10, 20};

    // Prevents narrowing
    // int x{3.14};  // Compiler error!
    int x = 3.14;    // Compiles (implicit conversion)

    // Empty initialization (zero/default)
    int zero{};      // 0
    std::string empty{};  // ""

    // Return value
    auto get_numbers = []() { return std::vector<int>{1, 2, 3}; };
}

// Most vexing parse solution
class Widget {
public:
    Widget() = default;
    Widget(int x) {}
};

void vexing_parse() {
    // Before C++11: declares a function!
    // Widget w();

    // Modern C++: creates an object
    Widget w{};     // Correct
    Widget w2{10};  // Also correct
}
```

## Move Semantics and Rvalue References

Move semantics enable efficient transfer of resources without copying,
crucial for performance.

```cpp
#include <vector>
#include <string>
#include <utility>
#include <iostream>

class Buffer {
    size_t size_;
    int* data_;

public:
    // Constructor
    Buffer(size_t size) : size_(size), data_(new int[size]) {
        std::cout << "Constructor\n";
    }

    // Copy constructor
    Buffer(const Buffer& other)
        : size_(other.size_), data_(new int[other.size_]) {
        std::copy(other.data_, other.data_ + size_, data_);
        std::cout << "Copy constructor\n";
    }

    // Move constructor
    Buffer(Buffer&& other) noexcept
        : size_(other.size_), data_(other.data_) {
        other.size_ = 0;
        other.data_ = nullptr;
        std::cout << "Move constructor\n";
    }

    // Copy assignment
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = new int[size_];
            std::copy(other.data_, other.data_ + size_, data_);
            std::cout << "Copy assignment\n";
        }
        return *this;
    }

    // Move assignment
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = other.data_;
            other.size_ = 0;
            other.data_ = nullptr;
            std::cout << "Move assignment\n";
        }
        return *this;
    }

    ~Buffer() { delete[] data_; }
};

void move_semantics_example() {
    Buffer b1(100);
    Buffer b2 = std::move(b1);  // Move, not copy

    std::vector<Buffer> buffers;
    buffers.push_back(Buffer(50));  // Move constructor used

    // Perfect forwarding
    auto make_buffer = [](auto&&... args) {
        return Buffer(std::forward<decltype(args)>(args)...);
    };
}
```

## Variadic Templates

Variadic templates enable functions and classes that accept any number of
arguments.

```cpp
#include <iostream>
#include <string>

// Base case
void print() {
    std::cout << "\n";
}

// Recursive variadic template
template<typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...);
}

// Fold expressions (C++17)
template<typename... Args>
auto sum(Args... args) {
    return (args + ...);
}

template<typename... Args>
auto sum_with_init(Args... args) {
    return (args + ... + 0);
}

// Perfect forwarding with variadic templates
template<typename T, typename... Args>
std::unique_ptr<T> make_unique_custom(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

void variadic_examples() {
    print(1, 2.5, "hello", std::string("world"));

    auto total = sum(1, 2, 3, 4, 5);  // 15

    // Fold expressions for various operations
    auto all_true = [](auto... args) {
        return (args && ...);
    };

    auto any_true = [](auto... args) {
        return (args || ...);
    };
}
```

## Structured Bindings (C++17)

Structured bindings decompose objects into their constituent parts,
improving code readability.

```cpp
#include <tuple>
#include <map>
#include <string>
#include <array>

struct Person {
    std::string name;
    int age;
    double salary;
};

std::tuple<int, std::string, double> get_employee() {
    return {42, "Alice", 75000.0};
}

void structured_bindings() {
    // Tuple decomposition
    auto [id, name, salary] = get_employee();

    // Pair decomposition
    std::pair<int, std::string> p{1, "one"};
    auto [num, text] = p;

    // Struct decomposition
    Person person{"Bob", 30, 80000.0};
    auto [pname, page, psalary] = person;

    // Array decomposition
    std::array<int, 3> arr{1, 2, 3};
    auto [a, b, c] = arr;

    // Map iteration
    std::map<std::string, int> scores{{"Alice", 95}, {"Bob", 87}};
    for (const auto& [name, score] : scores) {
        std::cout << name << ": " << score << "\n";
    }

    // References
    auto& [rname, rage, rsalary] = person;
    rage = 31;  // Modifies person.age
}
```

## Concepts (C++20)

Concepts constrain template parameters, providing better error messages and
clearer interfaces.

```cpp
#include <concepts>
#include <iostream>
#include <vector>

// Define custom concept
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// Use concept to constrain template
template<Numeric T>
T add(T a, T b) {
    return a + b;
}

// Concept with multiple constraints
template<typename T>
concept Printable = requires(T t) {
    { std::cout << t } -> std::convertible_to<std::ostream&>;
};

template<Printable T>
void print(const T& value) {
    std::cout << value << "\n";
}

// Range concept
template<typename T>
concept Range = requires(T r) {
    r.begin();
    r.end();
};

template<Range R>
void print_range(const R& range) {
    for (const auto& item : range) {
        std::cout << item << " ";
    }
    std::cout << "\n";
}

// Concept with associated types
template<typename T>
concept Container = requires(T c) {
    typename T::value_type;
    typename T::iterator;
    { c.begin() } -> std::same_as<typename T::iterator>;
    { c.end() } -> std::same_as<typename T::iterator>;
    { c.size() } -> std::convertible_to<std::size_t>;
};

template<Container C>
void process_container(const C& container) {
    std::cout << "Size: " << container.size() << "\n";
}

void concepts_example() {
    auto result = add(5, 10);      // OK
    auto dresult = add(5.5, 2.3);  // OK
    // auto sresult = add("hi", "there");  // Error: doesn't satisfy
                                             // Numeric

    print(42);
    print("Hello");

    std::vector<int> vec{1, 2, 3};
    print_range(vec);
    process_container(vec);
}
```

## Ranges Library (C++20)

The ranges library provides composable algorithms and views for working with
sequences.

```cpp
#include <ranges>
#include <vector>
#include <iostream>
#include <algorithm>

void ranges_examples() {
    std::vector<int> numbers{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // Views are lazy and composable
    auto even = [](int n) { return n % 2 == 0; };
    auto square = [](int n) { return n * n; };

    // Compose operations without intermediate containers
    auto result = numbers
        | std::views::filter(even)
        | std::views::transform(square)
        | std::views::take(3);

    for (int n : result) {
        std::cout << n << " ";  // 4 16 36
    }
    std::cout << "\n";

    // Range algorithms
    std::ranges::sort(numbers, std::greater{});

    // Find with projection
    struct Person {
        std::string name;
        int age;
    };

    std::vector<Person> people{
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35}
    };

    auto it = std::ranges::find(people, "Bob", &Person::name);

    // Views::iota for number generation
    for (int i : std::views::iota(1, 6)) {
        std::cout << i << " ";  // 1 2 3 4 5
    }
    std::cout << "\n";

    // Split view
    std::string text = "one,two,three";
    for (auto word : text | std::views::split(',')) {
        for (char c : word) {
            std::cout << c;
        }
        std::cout << " ";
    }
}
```

## Best Practices

1. Use `auto` for complex types and iterators but keep simple types explicit
2. Prefer lambdas over function objects for inline operations and callbacks
3. Use range-based for loops instead of manual iterator manipulation
4. Initialize variables with `{}` to prevent narrowing conversions
5. Implement move constructors and assignments for resource-owning classes
6. Use `std::move` when transferring ownership, not for general optimization
7. Prefer structured bindings over `std::get<>()` for tuples and pairs
8. Use concepts to constrain templates and improve error messages
9. Leverage ranges for composable, lazy operations on sequences
10. Use `const auto&` for range-based loops with large objects

## Common Pitfalls

1. Overusing `auto` making code less readable when types provide clarity
2. Capturing by reference in lambdas that outlive their captures
3. Using `std::move` on const objects, which disables move semantics
4. Forgetting `noexcept` on move operations, preventing optimizations
5. Modifying containers while iterating with range-based for loops
6. Dangling references from structured bindings of temporary objects
7. Using fold expressions without considering operator precedence
8. Assuming ranges views create copies instead of providing lazy views
9. Moving from objects that will be used again later
10. Not marking move constructors and assignments as `noexcept`

## When to Use Modern C++ Features

Use modern C++ features when you need:

- Cleaner, more expressive code with less boilerplate
- Better type safety with concepts and structured bindings
- Improved performance through move semantics
- Functional programming patterns with lambdas and ranges
- Generic programming with less template complexity
- Safer resource management with smart pointers
- Code that's easier to maintain and refactor
- Better compiler error messages with concepts
- Lazy evaluation and composition with ranges
- Migration from older C++ codebases to modern standards

## Resources

- [C++ Reference](https://en.cppreference.com/)
- [Modern C++ Tutorial](https://changkun.de/modern-cpp/)
- [Effective Modern C++](https://www.oreilly.com/library/view/effective-modern-c/9781491908419/)
- [C++20 Ranges](https://www.modernescpp.com/index.php/c-20-ranges-library)

© TheBushidoCollective · Apache-2.0 · TheBushidoCollective/han

Похожие скиллы

Все скиллы по теме «Языки программирования» →
141-java-refactoring-with-modern-features Juan Antonio Breña Moral Скилл 141-java-refactoring-with-modern-features для Claude Code переводит старый Java-код на современные возможности языка: лямбды, Stream API, Optional, java.time. Чистит легаси в рабочем проекте. CX Codex +1 459установок dart-modern-features kevmoo Скилл dart-modern-features обучает агента современному синтаксису Dart версий 3.0–3.10. Он помогает безопасно внедрять записи, extension types и модификаторы классов при рефакторинге. CX Codex +1 370установок modern-cpp trailofbits Скилл modern-cpp направляет код на C++ к стандарту C++20/23/26, убирая уязвимости памяти и устаревшие конструкции вроде сырых указателей и макросов. CX Codex +1 1 800установок v4-new-features phaserjs Скилл v4-new-features для изучения обновлений Phaser 4: Filters вместо FX, RenderNodes, новые игровые объекты (CaptureFrame, Gradient, Noise, SpriteGPULayer) и режимы тинта. Помогает разобраться в переписанном движке рендеринга. CX Codex +1 1 200установок cpp-coding-standards affaan-m Скилл cpp-coding-standards для ИИ-агентов, который подтягивает написание и ревью C++ к C++ Core Guidelines: RAII, иммутабельность, строгая типизация. CX Codex +1 7 100установок cpp-testing affaan-m Скилл cpp-testing для Claude Code ведёт агента по циклу red-green-refactor и настраивает GoogleTest с CMake/CTest. Восстанавливает стабильность падающих тестов на C++17/20. CX Codex +1 6 500установок

Из того же набора36

Весь набор →
rails-hotwire Скилл rails-hotwire для Claude Code, Codex, Cursor и других агентов, который учит строить реактивные Rails-приложения через Hotwire: Turbo Frames, Turbo Streams и Stimulus без тяжёлых JS-фреймворков. CX Codex +1 349установок angular-rxjs-patterns Скилл angular-rxjs-patterns для работы с RxJS в Angular: observable, операторы, subjects и управление подписками. Помогает писать реактивный код для асинхронных операций и стримов данных. CX Codex +1 292установок PHP Security Patterns Скилл PHP Security Patterns для Claude Code — справочник по безопасности PHP с примерами валидации ввода, подготовленных выражений PDO и экранирования вывода. Помогает править формы и запросы к базе. CX Codex +1 277установок django-rest-framework Скилл учит ассистента строить API на Django REST Framework с валидацией, вложенными сериализаторами и ViewSet. CX Codex +1 265установок react-native-web-testing Скилл react-native-web-testing помогает писать тесты для приложений на React Native Web с помощью Jest и React Native Testing Library. CX Codex +1 236установок tailwind-responsive-design Скилл tailwind-responsive-design помогает собирать адаптивные интерфейсы на Tailwind CSS: от mobile-first сеток до типографики и скрытия элементов по брейкпоинтам. CX Codex +1 235установок ansible-roles Скилл ansible-roles для Claude Code помогает разбить Ansible-автоматизацию на роли с понятной структурой. Организует задачи установки, настройки nginx и безопасности. CX Codex +1 234установок bdd-patterns Скилл bdd-patterns для Claude Code помогает писать BDD-спецификации, сценарии и критерии приёмки в формате Given–When–Then. Создаёт тесты, понятные разработчикам и бизнесу. CX Codex +1 211установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой