Introduction

std::merge and std::inplace_merge both combine sorted data, but they solve different layout problems. std::merge reads from two sorted input ranges and writes into a separate output range, while std::inplace_merge merges two consecutive sorted subranges that already live inside the same container.

std::merge Uses Separate Input and Output Ranges

Use std::merge when you have two sorted ranges and want the merged result somewhere else:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6    std::vector<int> left{1, 3, 5};
7    std::vector<int> right{2, 4, 6};
8    std::vector<int> out(left.size() + right.size());
9
10    std::merge(left.begin(), left.end(), right.begin(), right.end(), out.begin());
11
12    for (int value : out) {
13        std::cout << value << ' ';
14    }
15}

The input ranges stay unchanged, and you must provide enough output space for the merged result.

std::inplace_merge Works Inside One Existing Range

Use std::inplace_merge when one container already contains two consecutive sorted parts:

1#include <algorithm>
2#include <iostream>
3#include <vector>
4
5int main() {
6    std::vector<int> values{1, 3, 5, 2, 4, 6};
7
8    std::inplace_merge(values.begin(), values.begin() + 3, values.end());
9
10    for (int value : values) {
11        std::cout << value << ' ';
12    }
13}

Here, the first half and second half are each sorted already, and inplace_merge merges them into one sorted range in the same container.

The Middle Iterator Is the Key Difference

For std::inplace_merge, the middle iterator is essential because it marks where the first sorted subrange ends and the second begins.

Conceptually:

• '[first, middle) is sorted'
• '[middle, last) is sorted'
• after the call, [first, last) is sorted

That is a very different contract from std::merge, which takes two distinct source ranges and a separate destination iterator.

Memory and Use-Case Differences

std::merge clearly writes to another destination range, so its extra storage is visible in your code. std::inplace_merge works within one range, but it may still use temporary memory internally depending on the implementation.

The important practical choice is not “which one uses less memory in theory,” but “what layout does my data already have?”

Use:

• 'std::merge when you have two separate sources'
• 'std::inplace_merge when you have one range split into two sorted consecutive parts'

The Data Layout Decides the Choice

If your sorted values already sit in one container as adjacent ranges, std::inplace_merge fits naturally. If the data lives in two separate sources or you want a separate destination, std::merge is usually the clearer tool.

Common Pitfalls

• Calling either algorithm on ranges that are not already sorted in the required way.
• Using std::merge without allocating enough output space.
• Calling std::inplace_merge on two sorted ranges that are not consecutive in the same container.
• Forgetting that std::inplace_merge needs the correct middle iterator to identify the two sorted subranges.
• Choosing based on the function name alone instead of on the actual data layout.

Stable Merge Semantics Still Require Sorted Inputs

Both algorithms preserve order among equivalent elements when their preconditions are satisfied. If the inputs are not sorted correctly first, the algorithm choice is no longer the main problem.

Output Placement Is the Simplest Mental Shortcut

If you are unsure which algorithm you need, ask where the merged result should live. A separate destination suggests std::merge, while merging adjacent sorted ranges in one container suggests std::inplace_merge.

Summary

• 'std::merge merges two sorted input ranges into a separate output range.'
• 'std::inplace_merge merges two consecutive sorted subranges inside one existing range.'
• The key question is whether your sorted data is separate or already adjacent in one container.
• Both algorithms require sorted input in their expected layout.
• Pick the algorithm that matches the structure of your data, not just the one that sounds more convenient.