Quartz 4

C++ sizeof() operator explained ⚖️

6 min read

Metadata

  • Date :: 12-04-2025
  • Tags :: cpp

Notes

Detailed Notes on the sizeof Operator in C++

The sizeof operator in C++ is a compile-time operator that is used to determine the size, in bytes, of a variable, data type, class object, array, and other types of memory allocations. Understanding how sizeof works is essential for efficient memory management and understanding how different types and objects are allocated in memory.

1. Basic Usage of sizeof Operator

The sizeof operator is used to calculate the number of bytes that a variable or data type occupies in memory. This can be useful when trying to understand memory allocation, especially in cases where memory efficiency is a priority.

Syntax:

sizeof(variable)

or

sizeof(data_type)

When you pass a variable to the sizeof operator, it returns the size of the data type of that variable. You can also directly pass a data type itself to find out how much memory that data type requires.

2. Examples of sizeof Operator with Primitive Data Types

Let’s walk through a few examples to understand how the sizeof operator works with primitive data types and variables:

a. Example with double Data Type

In this example, the variable gpa is a double data type with a value of 2.5:

double gpa = 2.5;
std::cout << sizeof(gpa) << " bytes" << std::endl;
  • Output: 8 bytes

Explanation:

  • A double typically takes 8 bytes of memory, which is why sizeof(gpa) returns 8. The size of a double is fixed and depends on the system architecture and compiler, but generally, it is 8 bytes on most systems.

b. Example with string Data Type

In C++, the string class is a reference type, meaning it holds an address to the memory location where the actual data (the string) is stored.

std::string name = "John";
std::cout << sizeof(name) << " bytes" << std::endl;
  • Output: 32 bytes (This could vary based on the implementation of the string class and the system architecture.)

Explanation:

  • A std::string holds a pointer to a dynamically allocated memory space. In most systems, the size of a std::string object itself is typically 32 bytes because it stores the pointer and some extra information (like size and capacity of the string), not the actual string content. The content of the string is stored elsewhere in memory.

c. Example with char Data Type

In C++, a char is typically 1 byte in size:

char grade = 'A';
std::cout << sizeof(grade) << " byte" << std::endl;
  • Output: 1 byte

Explanation:

  • A char is guaranteed to be 1 byte according to the C++ standard, which is why sizeof(grade) returns 1.

d. Example with bool Data Type

Similarly, a bool variable stores either true or false, and it usually requires 1 byte of memory:

bool student = true;
std::cout << sizeof(student) << " byte" << std::endl;
  • Output: 1 byte

Explanation:

  • A bool in C++ typically takes 1 byte. Although it may seem that only 1 bit is necessary for a boolean value, the standard requires 1 byte to be allocated due to memory alignment constraints.

3. Example with Arrays

Arrays in C++ are contiguous blocks of memory, and the sizeof operator can be very useful to calculate the total size of the array in bytes.

a. Example with a Character Array

Let’s create an array of characters:

char grades[] = {'A', 'B', 'C', 'D', 'F'};
std::cout << sizeof(grades) << " bytes" << std::endl;
  • Output: 5 bytes

Explanation:

  • Each character in the array takes 1 byte, and since there are 5 characters, the total size of the array is 5 bytes.

b. Calculating the Number of Elements in an Array

To calculate the number of elements in an array, we can use the sizeof operator:

int numElements = sizeof(grades) / sizeof(grades[0]);
std::cout << "Number of elements in the array: " << numElements << std::endl;
  • Output: 5 elements

Explanation:

  • sizeof(grades) gives the total size of the array in bytes, and sizeof(grades[0]) gives the size of one element in the array (which is 1 byte for a char). By dividing the total size of the array by the size of a single element, we can find the number of elements in the array.

c. Example with an Array of Strings

Let’s consider an array of strings:

std::string students[] = {"Spongebob", "Patrick", "Squidward"};
std::cout << sizeof(students) << " bytes" << std::endl;
  • Output: 32 bytes

Explanation:

  • This shows that there are 3 elements (students) in the array. However, if you wish to find the size in bytes, you can also use sizeof to determine the overall memory size of the array.

To determine the number of elements in an array of strings:

int numElements = sizeof(students) / sizeof(students[0]);
std::cout << "Number of students: " << numElements << std::endl;
  • Output: 3 students

Explanation:

  • The sizeof(students) gives the total size of the array of strings, and dividing it by sizeof(students[0]), which gives the size of a single string object, will give the number of strings in the array.

4. Important Considerations

  • Pointer vs Data Size: When you apply sizeof to a pointer, it returns the size of the pointer, not the size of the data being pointed to. For example:

    int* ptr;
std::cout << sizeof(ptr) << " bytes" << std::endl;
    • Output: 4 bytes (on a 32-bit system)

    Even though the pointer ptr points to an integer (which is usually 4 bytes), the sizeof(ptr) gives the size of the pointer itself, which is typically 4 bytes on a 32-bit system or 8 bytes on a 64-bit system.

  • Dynamic Memory: If you’re dealing with dynamically allocated memory (e.g., using new), the sizeof operator does not account for the memory allocated dynamically. It only tells you the size of the pointer, not the allocated memory.

5. Conclusion

The sizeof operator is a crucial tool in C++ that helps developers manage and understand memory usage. By determining the size of variables, data types, arrays, and objects, developers can make more informed decisions about memory allocation and optimization. It’s especially helpful in situations like working with arrays, determining alignment, and ensuring that memory is used efficiently.

Understanding how different data types and objects are stored in memory, along with the sizeof operator’s role, will be important as you work with larger and more complex programs, particularly when dealing with low-level programming or memory-constrained environments.

References

Graph View

Backlinks