Memory Efficiency Regarding The Use of Unions in C++

Question

Consider the three code blocks below, three alternative solutions to the string/union conflict.

Of these options, in general, which is more memory efficient regarding the use of unions in this fashion?

I'm looking for answers addressing principle here: that is, the primary purpose of unions is to save memory.

EDIT: A class assignment forced me to use unions in this way. It had me thinking which was the most efficient, and that's how I got here.

Code Block (A):

// unions with pointers to structs
struct HourlyInfo {
    string firstName;
    string lastName;
    string title;
    int hoursWorked;
    double hourlyRate;
};

struct SalaryInfo {
    string firstName;
    string lastName;
    string title;
    double salary;
    double bonus;
};

struct Employee {
    bool isHourly;
    union {
        HourlyInfo *hourlyEmployee;
        SalaryInfo *salaryEmployee;
    }

};

Code Block (B):

// applying unions to relevant and non-string data types
struct Employee {
    string firstName;
    string lastName;
    string title;
    bool isHourly;
    union {
        struct {
            double hourlyRate;
            int hoursWorked;
        } hourly;
        struct {
            double salary;
            double bonus;
        } salaried;
    };
};

Code Block (C):

// use cstring instead of string
struct HourlyInfo {
    cstring firstName[50];
    cstring lastName[50];
    string title[50];
    int hoursWorked;
    double hourlyRate;
};

struct SalaryInfo {
    cstring firstName[50];
    cstring lastName[50];
    cstring title[50];
    double salary;
    double bonus;
};

struct Employee {
    bool isHourly;
    union {
        HourlyInfo hourlyEmployee;
        SalaryInfo salaryEmployee;
    }
};

(Note: The idea behind the code is that any employee is either hourly or salary, thus the union here. Please don't suggest alternative solutions to this problem that do not involve unions. I'm not worried about solving a specific problem, I'm interested in unions.)

---

Also, pointers and other data types seem to vary greatly in their sizes:

What does the C++ standard state the size of int, long type to be?

How much memory does a C++ pointer use?

Does this mean there is no blanket statement we can make about memory efficiency here? If so, which factors should we consider in determining most-efficient methods?

Answer 1

Rule #1: follow your profiler (it will tell you which is more effective for your program)

Rule #2: regarding memory allocations: employ custom allocators to hide the complexity for you

Rule #3: design your datatypes for clear expression of intent/purpose (in that sense, only B is an option). Of course, unless Rule #1 necessitates another take (that's pretty unusual)

I know I'm "not allowed" to propose alternatives: (Live on Coliru)

#include <string>
#include <boost/variant.hpp>

struct HourlyInfo {
    int    hoursWorked;
    double hourlyRate;
};

struct SalaryInfo {
    double salary;
    double bonus;
};

namespace detail {

    template <template <typename...> class Allocator = std::allocator>
    struct basic_employee {
        using string = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
        string firstName;
        string lastName;
        string title;

        using RateInfo = boost::variant<HourlyInfo, SalaryInfo>;
        RateInfo rates;
    };
}

using Employee = detail::basic_employee<>; // or use a custom (pool?) allocator

int main()
{
    Employee staff1 = { 
        "John", "Cage", "From accounting", 
        SalaryInfo { 1900.00, 120.0 } 
    };
    Employee contractor = { 
        "Joe", "Duffy", "Plumbing jobs", 
        HourlyInfo { 3, 46.00 } 
    };
}

Answer 2

B will probably use least memory, but 50 was a good number to pick because it leaves it in doubt.

With A, presumably you're going to make a separate memory allocation of one of the two possibilities. In terms of memory use this will pretty much always introduce some inefficiency, plus there's the space for the pointer itself, so it loses to B. It could potentially win, though, in the peculiar case where the two info structs differ in size by more than the size of a pointer, more than a certain proportion use the smaller struct, and you allocate them from a ferociously low-overhead memory allocator such as a pool allocator.

With C I assume you mean an array of 50 char, not an array of 50 string or cstring. I believe that the average length of a name, plus the overhead of string, is less than 50 characters, and that's the basis on which I say that B beats C. However, you are correct that the overhead of string depends on some implementation details, so I can't say this categorically. Furthermore, if you're dealing with people whose names are all slightly under 50 characters then C would win. I just think that's unlikely.

Of course, C is more limited in that it cannot deal at all with someone who has a name over 50 characters (49 if you store the strings nul-terminated).

[Edit: thinking about it again, the overhead of a string could be:

• 8 bytes for a start pointer
• 8 bytes for an end pointer
• 8 bytes for capacity
• two more pointers (16 bytes) for the header of the allocation that contains the string data, with the allocation itself rounded up to 8 or 16 bytes.

Total 48 or 56 bytes for a short string (although there's a thing called "short string optimization" that makes short strings better, although depending on details it could make long strings worse). With that implementation of string and memory allocation, C would win, and even without the rounding up it might well win in Sri Lanka.

So, it is worth working out how to measure the actual memory use.]