Go vs C++: Memory Efficiency in String Merging

This article compares the memory consumption of two string merging algorithms, one implemented in Go using byte slices and the other in C++ using strings. We analyze why the Go version exhibits lower memory usage.

Code Example 1 (Go):

func mergeAlternately(word1, word2 string) string {
    n, m := len(word1), len(word2)
    ans := make([]byte, 0, n+m)
    for i := 0; i < n || i < m; i++ {
        if i < n {
            ans = append(ans, word1[i])
        }
        if i < m {
            ans = append(ans, word2[i])
        }
    }
    return string(ans)
}

Code Example 2 (C++):

class Solution {
public:
    string mergeAlternately(string word1, string word2) {
        int m = word1.size(), n = word2.size();
        int i = 0, j = 0;
        string ans;
        ans.reserve(m + n);
        while (i < m || j < n) {
            if (i < m) {
                ans.push_back(word1[i]);
                i++;
            }
            if (j < n) {
                ans.push_back(word2[j]);
                j++;
            }
        }
        return ans;
    }
};

Why Code 1 consumes less memory:

Code 1 uses a byte slice ([]byte) in Go to store the result, while Code 2 uses a string (string) in C++. Byte slices in Go are more memory-efficient compared to strings because they only store the raw byte data. Strings, on the other hand, require additional storage for length information and character encoding, leading to higher memory consumption.

Therefore, Code 1, utilizing byte slices in Go, demonstrates a lower memory footprint compared to Code 2, which employs strings in C++.