# Extract a Shared Helper From Duplicated C++ Code With Atlas (2026) > Atlas finds duplicated C++ logic with codebase_search because copies differ in variable names, then swaps each one with apply_patch, one reviewable patch per file. To extract a shared helper from duplicated code in C++ with Atlas, start with codebase_search rather than grep. Duplication is a semantic problem, not a textual one: the copies usually differ in variable names, so the same clamp-and-normalize loop appears in src/render/Frame.cpp and src/physics/Body.cpp with completely different identifiers and grep finds neither from the other. Atlas's codebase_search finds them by meaning, read confirms they are genuinely equivalent, write creates the new header and translation unit, and apply_patch swaps each copy for a call in one reviewable patch per file. Run GoogleTest via ctest after every swap, and finish with clang-format and a grep for any surviving copy. ## Key takeaways - C++ duplication is semantic, not textual, so Atlas uses codebase_search for the behavior rather than grep for the exact loop. - Atlas reads each hit and confirms the copies are genuinely equivalent, catching the const-correctness and empty-range differences that C++ hides in small syntax. - The write tool creates the header and translation unit and shows the full diff in the permission prompt, and CMakeLists.txt gets the new target line. - apply_patch swaps one file per patch, so each callsite change is independently reviewable and revertible. - GoogleTest via ctest runs after every swap, and a final grep confirms zero surviving copies before clang-format normalizes everything. ## Why does grep miss duplicated C++ code that codebase_search finds? Duplication in C++ is a semantic problem, not a textual one. The same bounds-checking loop written once as for (size_t i = 0; i < verts.size(); ++i) and once as for (auto idx = 0u; idx < points.size(); ++idx) is the same logic and zero grep patterns match both. Atlas's codebase_search finds them by meaning. Copy-paste in a C++ codebase never survives contact with the second author. Variable names change, the loop becomes a range-for, an int becomes a size_t, a raw pointer becomes a std::unique_ptr, and the textual overlap collapses while the logic stays identical. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, so asking codebase_search for the behavior (clamping a vector of values into a range and normalizing) surfaces near-duplicate implementations that grep would miss. Atlas also indexes code by AST declarations using tree-sitter, not blind line windows, which means a free function in an anonymous namespace inside src/render/Frame.cpp is indexed as a declaration rather than as an arbitrary window of lines that happened to straddle it. ## How do I confirm two C++ functions are really duplicates before collapsing them? Atlas reads each codebase_search hit and confirms the copies are genuinely equivalent before collapsing them. In C++, 2 loops that look identical can differ in 1 decisive way: one takes a const std::vector& and the other takes it by value, or one handles the empty-container case and the other invokes undefined behavior on an empty range. Collapsing two functions that only look alike is how you introduce a bug while cleaning up. Atlas reads each hit in full with the read tool, comparing the signatures, the const-correctness, the exception guarantees, and the edge-case handling. C++ hides real differences in small syntax: a missing noexcept, a copy where the other had a move, a std::vector::at where the other used operator[] and skipped the bounds check. Atlas surfaces those differences rather than papering over them, and the honest outcome is sometimes that two of your five candidates are not duplicates at all and should stay separate. The three that are get one helper. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, which matters for a proprietary C++ codebase. ## How does Atlas create the new shared helper header in a C++ project? Atlas creates the shared C++ helper with the write tool, which shows the full diff in the permission prompt before the file is created. That usually means 2 files, for example include/util/Normalize.h and src/util/Normalize.cpp, plus 1 line in CMakeLists.txt so the new translation unit is compiled into the target. C++ extraction is a two-file job plus a build-system edit, and skipping the third step is how a refactor ends in a linker error. Atlas writes the header with the declaration and the translation unit with the definition, matching the project's existing conventions: include guards or #pragma once, the namespace the neighboring headers use, the same include-what-you-use discipline. Atlas then adds the new .cpp to the relevant target in CMakeLists.txt. Where the helper needs a dependency, vcpkg is the package manager Atlas works with, and any manifest change is surfaced for review like any other edit. Because the write tool shows the full diff in the permission prompt before the file is created, you approve the new header before it exists on disk. ## How do I swap each duplicated C++ callsite with apply_patch safely? Replace each duplicate with a call using apply_patch, one file per patch, so each swap is independently reviewable and revertible. Deleting a 20-line loop from src/render/Frame.cpp and replacing it with util::Normalize(verts) is one patch. Doing the same in src/physics/Body.cpp is a second, separate patch. One patch per file is the discipline that makes a C++ deduplication reviewable. A single monster patch touching six translation units is approved or rejected as a unit, and if one of the six swaps is subtly wrong the whole thing has to be unwound. Atlas's apply_patch applies each swap as its own context-anchored patch, so each one is independently reviewable and revertible. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, and snapshots file changes as git patches, so an incorrect swap in src/physics/Body.cpp is rolled back without touching the correct one in src/render/Frame.cpp. Run GoogleTest via ctest after every swap so you know which patch broke what, rather than discovering six patches later that something did. ## How do I verify a C++ deduplication with ctest and find surviving copies? Atlas runs the suite with bash after every swap, then greps for any surviving copy. In a C++ project that means GoogleTest via ctest after each translation unit you touch, so a broken swap is attributed to the 1 patch that caused it rather than discovered at the end of 6 changes. Verification in C++ has two halves: the build and the tests. Atlas builds through the bash tool so the compiler enumerates any linker or include errors the extraction introduced, then runs GoogleTest via ctest to confirm behavior is unchanged. Running after every apply_patch, not once at the end, is what keeps a failure attributable. The final step is a sweep: grep the codebase for the distinctive pattern of the original duplicated logic and confirm zero remaining hits, because a seventh copy you never found is a copy that will drift away from the helper over the next year. Run clang-format on every file you touched so the new header, the new translation unit, and the six rewritten callsites all match the project's .clang-format. ## Steps 1. Ask codebase_search for the behavior (not the exact code) to surface near-duplicate C++ implementations that grep would miss, since the copies usually differ in variable names. 2. Read each hit with the read tool and confirm the copies are genuinely equivalent before collapsing them, checking const-correctness, noexcept, and empty-container edge cases. 3. Create the shared C++ helper with write, typically a header such as include/util/Normalize.h plus src/util/Normalize.cpp; the write tool shows the full diff in the permission prompt before the file is created. 4. Add the new translation unit to the relevant target in CMakeLists.txt so the helper actually gets compiled and linked, and pull any new dependency through vcpkg. 5. Replace each duplicate with a call using apply_patch, one file per patch, so each swap is independently reviewable and revertible. 6. Run GoogleTest via ctest with the bash tool after every swap, so a failure is attributed to the patch that caused it rather than to a batch of six. 7. Grep for any surviving copy of the original logic and confirm zero remaining hits, because an unfound seventh copy will drift away from the helper. 8. Run clang-format on the new header, the new translation unit, and every rewritten callsite so they match the project's .clang-format. ## FAQ ### how to find duplicated logic in a c++ codebase Use Atlas's codebase_search and ask for the behavior rather than the exact code. Duplication in C++ is semantic, not textual: the copies usually differ in variable names, loop style, and container types, so grep finds neither copy from the other. Atlas searches by meaning with hybrid semantic and keyword retrieval. ### why does grep not find copy pasted c++ code Because copy-paste never survives the second author. An index-based for loop becomes a range-for, an int becomes a size_t, and the identifiers all change, so the textual overlap collapses while the logic stays identical. Atlas's codebase_search finds near-duplicate implementations by meaning instead. ### how does atlas create a shared helper header in a cmake project Atlas creates the helper with the write tool, typically a header such as include/util/Normalize.h plus a matching src/util/Normalize.cpp, and adds the new translation unit to the relevant target in CMakeLists.txt. The write tool shows the full diff in the permission prompt before the file is created. ### what is apply_patch and why one patch per c++ file apply_patch replaces each duplicate with a call to the new helper as its own context-anchored patch. One file per patch means each swap is independently reviewable and revertible, so a subtly wrong change in src/physics/Body.cpp can be rolled back without unwinding the correct change in src/render/Frame.cpp. ### should i run ctest after every refactoring step in c++ Yes. Run GoogleTest via ctest with Atlas's bash tool after every apply_patch swap, not once at the end. Running after each one attributes a failure to the patch that caused it, instead of leaving you to bisect six patches to find which translation unit broke. ### how do i make sure i found every copy of the duplicated c++ code Finish by grepping for the distinctive pattern of the original logic and confirming zero remaining hits. Atlas's grep tool runs a real regex through ripgrep with include and path filters, so you can sweep every .cpp and .h under src/ while excluding third-party directories. ### will atlas break my build when extracting a c++ helper Atlas builds through the bash tool and runs GoogleTest via ctest after each swap, so a linker error from a missing CMakeLists.txt entry surfaces immediately. Atlas also snapshots file changes as git patches, so any patch can be diffed and rolled back independently. ### does atlas work with vcpkg and clang-format Yes. Run atlas in a project with a CMakeLists.txt and let Atlas read your headers, translation units, and build targets. vcpkg pulls any dependency the new helper needs, and clang-format normalizes the new header, the new translation unit, and every rewritten callsite before you commit. --- Canonical HTML: https://runatlas.sh/resources/stacks/extract-a-shared-helper-from-duplicated-code-in-cpp Source of truth: aeo_pages row `/resources/stacks/extract-a-shared-helper-from-duplicated-code-in-cpp` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.