Dynamically allocated size

Is there a way to determine the size of an object/variable that you have dynamically allocated memory to? For example:

Code:

---

int foo() {
    int x;
    return sizeof(x);
}

---

returns 4, or the size of an int.

Code:

---

int foo() {
    char* data = new char[128];
    int size = ???;
    delete {} data;
    return size;
}

---

Is there a way to determine the size of the above dynamically allocated character array?

To use new char[128] implies that you know that the size is 128.

I would say that the solution is to keep track of the size of the dynamic array with another variable.

Oh, and it is delete[] data, not delete{} data.

Quote:

---

Originally Posted by laserlight

I would say that the solution is to keep track of the size of the dynamic array with another variable.

---

That's what I've always done. just wondering if there was some voodoo I wasn't aware of. Sorry bout the typo.

That said, I would prefer std::string or std::vector<char> if I can.

Code:

---

size_t _msize( void *memblock );

---

Quote:

---

Originally Posted by Brad0407

Code:

---

size_t _msize( void *memblock );

---

---

I think this gives some good reasons not to use _msize.

I'll let the function speak for itself:

Code:

---

#include <iostream>
#include <malloc.h>

int foo() {
    char* data = new char[128];
    int size = _msize(data);
    delete [] data;
    return size;
}

int main()
{
        std::cout << "foo() returns " << foo() << "\n";
        return 0;
}

---

If you have a better idea, let me know.

Try not to have plain pointers in the code. If, for some reason you don't think you can use a vector or any other standard container, put the pointer in a class that also has the size member.

Quote:

---

Originally Posted by maverickbu

That's what I've always done. just wondering if there was some voodoo I wasn't aware of. Sorry bout the typo.

---

By interrogating the size of the array and dividing it by the size of the type of data it holds you can use;

Code:

---

int size = sizeof(data)/sizeof(char);

---

Quote:

---

When you have a better idea, let me know.

---

Code:

---

#include <iostream>
#include <vector>

int foo() {
    std::vector<char> data(128);
    return data.size();
}

int main()
{
        std::cout << "foo() returns " << foo() << "\n";
        return 0;
}

---

Or even:

Code:

---

#include <iostream>

int foo() {
    return 128;
}

int main()
{
        std::cout << "foo() returns " << foo() << "\n";
        return 0;
}

---

The point is that it is non-standard and non-portable, and consequently may not return the size as expected for this purpose.

Quote:

---

By interrogating the size of the array and dividing it by the size of the type of data it holds you can use;

---

In this case it would just give the size of the pointer.

Quote:

---

Originally Posted by indigo0086

By interrogating the size of the array and dividing it by the size of the type of data it holds you can use;

Code:

---

int size = sizeof(data)/sizeof(char);

---

---

size will always be 4 as long as pointers are stored in 32 bits of memory and characters in 8 bits.

>> The point is that it is non-standard and non-portable, and consequently may not return
>> the size as expected for this purpose.

Amen

Ah, missed the vectors thing. Either way vectors are better.

There are two more problems with _msize, aside from the obvious (it's compiler specific):
1) new[] might be overloaded and not call malloc at all.
2) new[] might allocate some additional bookkeeping memory that malloc (and thus _msize) is not aware of. The result would be that the result of _msize might not be evenly divisible by the item size, or the division may result in a higher item count than is actually available.