cpp
This skill covers contemporary C++ practices from C++11 onward, emphasizing memory safety through smart pointers (unique_ptr, shared_ptr, weak_ptr) and the RAII pattern for automatic resource cleanup. You'll explore move semantics and perfect forwarding to optimize performance, dive into function and class templates with specialization techniques, and learn STL containers and algorithms for efficient data manipulation.
cpp teaches modern C++ patterns for memory management, resource safety, and performance optimization.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-01-20
cpp teaches modern C++ patterns for memory management, resource safety, and performance optimization. This skill covers contemporary C++ practices from C++11 onward, emphasizing memory safety through smart pointers (unique_ptr, shared_ptr, weak_ptr) and the RAII pattern for automatic resource cleanup. You'll explore move semantics and perfect forwarding to optimize performance, dive into function and class templates with specialization techniques, and learn STL containers and algorithms for efficient data manipulation.
Use it when
- cpp covers smart pointers including unique_ptr, shared_ptr, and weak_ptr for safe memory management without manual allocation/deallocation.
- cpp explores function and class templates with specialization techniques, variadic templates, fold expressions.
Verify before relying
Read SKILL.md below before installing (3 files). Open directory: indexed for reading, not audited.
Install
miles990/claude-software-skills/cpp · repository language: TypeScript
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
What modern C++ programming patterns does cpp cover?
cpp teaches contemporary C++ practices from C++11 onward, with emphasis on memory safety through smart pointers (unique_ptr, shared_ptr, weak_ptr) and the RAII pattern for automatic resource cleanup. You'll learn move semantics, perfect forwarding, function and class templates with specialization, STL containers and algorithms, and advanced idioms for performance-critical systems code.
How does cpp handle C++ smart pointers and memory management?
cpp covers smart pointers including unique_ptr, shared_ptr, and weak_ptr for safe memory management without manual allocation/deallocation. The skill emphasizes the RAII (Resource Acquisition Is Initialization) pattern, scope guards, and best practices for automatic resource cleanup. You'll learn to avoid circular references and implement memory-safe designs in modern C++.
What does cpp teach about C++ templates and template specialization?
cpp explores function and class templates with specialization techniques, variadic templates, fold expressions, and the CRTP (Curiously Recurring Template Pattern). You'll master generic programming, constexpr evaluation, and C++20 concepts with requires clauses for compile-time programming and type-safe generic code.
Does cpp cover multithreading and concurrent programming?
Yes, cpp teaches multithreading in C++ using async, future, atomic operations, mutexes, and condition variables. You'll learn to implement efficient concurrent applications, build thread-safe data structures like queues, and apply synchronization patterns for safe multithreaded systems.
What STL and functional programming topics are in cpp?
cpp covers STL containers (vector, map, etc.), algorithms, lambda expressions with various capture modes, and generic lambdas with auto parameters. You'll master functional programming patterns, the remove-erase idiom, and efficient data manipulation techniques using modern C++ standard library features.
How does cpp address error handling and resource safety?
cpp teaches modern error handling using optional and variant types instead of exceptions in performance-critical code. Combined with RAII, smart pointers, and scope guards, these patterns ensure resources are properly managed and exceptions don't leak resources, providing robust and predictable error handling.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
C++
Overview
Modern C++ (C++11 and beyond) patterns including RAII, smart pointers, templates, and STL.
Modern C++ Fundamentals
Smart Pointers
```cpp
include <memory>
include <iostream>
// unique_ptr - exclusive ownership class Resource { public: Resource() { std::cout << "Resource acquired\n"; } ~Resource() { std::cout << "Resource released\n"; } void use() { std::cout << "Resource used\n"; } };
void unique_ptr_example() { // Create unique_ptr auto ptr = std::make_unique<Resource>(); ptr->use();
// Transfer ownership
auto ptr2 = std::move(ptr);
// ptr is now nullptr
// Array support
auto arr = std::make_unique<int[]>(10);
}
// shared_ptr - shared ownership void
(truncated - see the full file via the links below)
File tree — 3 files
programming-languages/cpp/SKILL.md
programming-languages/cpp/templates/CMakeLists.txt
programming-languages/cpp/templates/README.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Learn modern C++ patterns for memory management and resource safety”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
C++ Expert provides in-depth instruction on contemporary language standards and advanced development practices. Learn concepts, ranges, coroutines, and memory strategies alongside performance techniques like zero-cost abstractions and compile-time computation. Build proficiency with smart pointers, move semantics, and template metaprogramming for production-grade applications.
This skill delivers comprehensive coding standards rooted in the C++ Core Guidelines, covering modern C++17/20/23 practices. It emphasizes type safety, resource management through RAII, immutability by default, and clear intent in code design. Use it when writing new code, reviewing existing implementations, or making architectural decisions to enforce consistent, safe, and idiomatic C++ across your projects.
cpp-rules provides comprehensive C++ development standards drawn from ai-toolkit's rule library. It covers naming conventions, modern language features, memory management with smart pointers, and framework guidance for CMake, Boost, Qt, and gRPC. The rules emphasize RAII patterns, error handling strategies, concurrency practices, and design patterns to maintain code quality and security across C++ projects.
This skill guides developers through modern C++ best practices rooted in the C++ Core Guidelines, covering type safety, resource management via RAII, immutability, and clear interfaces. Apply it when writing, reviewing, or refactoring C++ code to maintain consistency and prevent common errors across your codebase.
Cpp Idioms teaches you how to write safe, efficient C++ code using modern language features and proven design patterns. Learn RAII principles, smart pointer ownership models, move semantics, and error handling with std::expected—all grounded in C++17/20/23 standards. The skill covers interfaces, dependency injection, testing strategies, and anti-patterns to avoid, with practical code examples and tooling guidance.
This skill guides you through building robust C++ code with emphasis on type-safe API design, clear ownership patterns, and maintainable file organization. It covers RAII principles, async boundaries, and integration with React Native Nitro Modules, helping you write native code that's predictable and easy to review.
More skills cpp-pro (MIT) · Qt Cpp Review (NOASSERTION) · ruby (MIT) · php (MIT)