meyers_skill

Overview

This skill encodes Scott Meyers' Effective C++ principles into practical, actionable guidance for writing robust C++ code. It emphasizes designing interfaces that are easy to use correctly, minimizing surprises from implicit language behavior, and favoring compile-time safety. Use it to produce code that is correct, maintainable, and efficient in production settings.

How this skill works

The skill inspects C++ design and implementation choices and suggests concrete patterns: safer constructors, assignment idioms, initialization rules, dependency minimization, and preferred use of non-member functions. It highlights common gotchas (implicit special members, self-assignment, virtual behavior) and recommends idiomatic fixes (explicit single-argument constructors, copy-and-swap, pImpl, value semantics). Advice is paired with short rationale so users understand the underlying C++ mechanics.

When to use it

• Designing public APIs or library interfaces
• Refactoring code to improve safety and maintainability
• Implementing resource-managing types (RAII) and assignment/ctor behavior
• Reducing header dependencies and speeding builds
• Preparing code for code review or production release

Best practices

• Make interfaces easy to use correctly and hard to misuse
• Prefer compile-time checks over runtime behavior; use type system and explicit constructors
• Always initialize members in declaration order; prefer initialization over assignment
• Declare destructors virtual in polymorphic bases and never let exceptions escape destructors
• Implement operator= safely (handle self-assignment) using copy-and-swap or strong exception-safe patterns
• Minimize header coupling (pImpl, forward declarations) and prefer non-member non-friend functions for algorithms

Example use cases

• Convert error-prone constructors to type-safe parameter types (e.g., Month/Day/Year)
• Replace unsafe assignment operators with copy-and-swap to handle self-assignment and exceptions
• Introduce pImpl to reduce compilation dependencies and hide implementation details
• Refactor utility algorithms into non-member functions to keep class interfaces small
• Audit a class for implicitly-generated special members and explicitly declare/define where needed