What is the size of a char*?

Question

What is the size of a char*, or how would I be able to get the size of it? Would it simply be

sizeof(char)

or

sizeof(char[])

I am asking this because I am trying to make a data structure (a queue) that holds char* as its data type and for the initialization/creation of the queue, I need to pass in the size of the data type as a parameter. If it were an integer:

queue* q = createQueue(sizeof(int))

How would I do something like this for a char*? Would something like this work or do I have the wrong idea? Do I need to use char**, but then I believe that the implementation of the queue would need to change since I am following a generic queue implementation I found on GitHub.

Answer 1

char* is a pointer, thus has the same size than any other pointer (int*, void*...). On 64-bit CPU, pointer size is 8-bytes.

You can simply write sizeof(char*)

https://onlinegdb.com/ySTtpNFSg

Answer 2

There’s nothing magic about pointer types - a pointer has a size like any other object type¹, so it’s just as valid to use sizeof (char *) as sizeof (char).

Pointer type sizes are as big as the implementation needs them to be, and different pointer types may have different sizes². Similarly, the internal representation of pointer types can vary among implementations.

Remember that sizeof is an operator, not a function; parens are only required if the operand is a type name. Also, unless its operand is a variable-length array, sizeof expressions are evaluated at compile time, not runtime. Similarly, sizeof only cares about the type of its operand, not its value or how it’s stored. You can use sizeof on expressions as well as type names - a common idiom for malloc is

T *p = malloc( N * sizeof *p ); // for any type T

The expression *p has type T, so sizeof *p == sizeof (T).

---

1. void is an incomplete type that cannot be completed - you cannot create an object of void type and strictly speaking the type has no size. You can, however, create an object of void * type, and its size and alignment will be the same as char *. A void * is a "generic" pointer type and can be converted to other pointer types without an explicit cast. Since there's no such thing as a void object, you cannot dereference a void * - you have to convert it to another pointer type first.
2. On common platforms like x86 all pointer types have the same size, but that’s not required.

Answer 3

As mentioned in other comments, the char* is a pointer, so it is a number referencing the memory position where the actual char is. I would like to add that the actual size may depend on the architecture of the computer as mentioned here.

For further reference about size of types see this link of the cppreference website.

Answer 4

sizeof(char*) returns the size of a pointer.

If you're compiling for the x86, it's virtually guaranteed to be 4 bytes.
If you're compiling for the x64, it's virtually guaranteed to be 8 bytes.

Yes, it's perfectly valid to get the size of a pointer. While it would be a bit odd to allocate a single pointer dynamically, it's quite common to allocate an array of them. For example, say you have wanted to genericize your queue. The first thing you'd do is make it a queue of pointers.

typedef struct {
   size_t capacity;
   size_t count;
   void **array;
   // ...
} Queue;

int Queue_init(Queue *q) {
   q->capacity = 10;
   q->array = malloc(sizeof(void*) * q->capacity);
   if (!q->array)
      return 0;

   q->count = 0;
   // ...

   return 1;
}