Thread: size of dynamically allocated block of memory

Why does the output for the dynamically allocated array show 1 vs the fixed array shows 0 even though both are don't have elements initially.

It seems trivial...

Code:

#include <iostream>

using namespace std;

int main()
{
    int* dynamic_list = new int[7];
    
    int dynamic_list_size = sizeof(dynamic_list)/sizeof(int);
    
    cout << dynamic_list_size << endl;
    
    int list[] = {};
    int list_size_ = sizeof(list)/sizeof(int);
    cout << list_size << endl;
  return 0;
}

Because sizeof(dynamic_list) is equal to the size of an int,and you divide it by the size of an int so it gives you one.
The list however is empty so, what are doing is actually zero/sizeof(int)=0.In my system sizeof(int)=4

if you're using new to make arrays, you have to keep track of the size. the system does not do it for you like in other languages.

My tinkering:

Code:

#include <iostream>
#include <algorithm>

int main()
{
    size_t dynamic_list_size = 7;
    // We need a size for the dynamic list *before* we make the list.
    int *list = new int[dynamic_list_size];

    for (size_t i = 0; i < dynamic_list_size; i++)
    {
        list[i] = 2 * (i + 1);
    }

    // Now supposing that you want to make a separate copy stored
    // on the stack...
    int stacklist[(const size_t)dynamic_list_size];
    // Note the use of a constant expression - it's required.

    std::copy(list, list + dynamic_list_size, stacklist);
    // Of particular note, we are copying ints to an int array. So
    // there is no real danger of code like "delete[] list;" making
    // stacklist being full of invalid pointers.

    // Read http://www.cplusplus.com/reference/algorithm/copy/ too.

    // Let's just see if they are the same.
    for (size_t i = 0; i < dynamic_list_size; i++)
    {
        std::cout << "list[" << i << "] = " << list[i] << "\t";
        std::cout << "stacklist[" << i << "] = " << stacklist[i] << std::endl;
    }

    delete[] list; // Release list because it was newed

    // stacklist will fall out of scope and be destroyed.
    return 0;
}

Now go from there.

It really isn't all that difficult once you get the hang of it, but the point of C++ is that now you don't necessarily have to think about these low-level processes with classes like array and vector. You also won't learn stuff, like what goes on in vector<T>::insert(), so it can impede your understanding of how the array data structure actually works somewhat, unless you avoid using insert(). My personal opinion is that vector and friends are helpful and you should start out with them... but it can be fun to restrict yourself and learn more. Just my $0.02.

Code:

int stacklist[(const size_t)dynamic_list_size];

That's not a constant expression just because you wish it was a constant expression.

"G++" is allowing this because it allows the "dynamic stack arrays" from C99 even in C++.

Code:

const size_t dynamic_list_size = 7;

If you want a real constant expression, you have to stick with only bits that are constant expressions.

Soma

"G++" is allowing this because it allows the "dynamic stack arrays" from C99 even in C++.

Well isn't that just ........ing great.

That isn't intuitive at all.

The -ansi flags removes GNU extensions that conflict with ISO C++. And it doesn't mean the same as -std=C++98. You can use -ansi with any of the supported C++ standard. See the following link. Using the GNU Compiler and from that link:

-ansi
In C mode, support all ISO C89 programs. In C++ mode, remove GNU extensions that conflict with ISO C++.

This turns off certain features of GCC that are incompatible with ISO C89 (when compiling C code), or of standard C++ (when compiling C++ code), such as the asm and typeof keywords, and predefined macros such as unix and vax that identify the type of system you are using. It also enables the undesirable and rarely used ISO trigraph feature. For the C compiler, it disables recognition of C++ style // comments as well as the inline keyword.

The alternate keywords __asm__, __extension__, __inline__ and __typeof__ continue to work despite -ansi. You would not want to use them in an ISO C program, of course, but it is useful to put them in header files that might be included in compilations done with -ansi. Alternate predefined macros such as __unix__ and __vax__ are also available, with or without -ansi.

The -ansi option does not cause non-ISO programs to be rejected gratuitously. For that, -pedantic is required in addition to -ansi. See Warning Options.

The macro __STRICT_ANSI__ is predefined when the -ansi option is used. Some header files may notice this macro and refrain from declaring certain functions or defining certain macros that the ISO standard doesn't call for; this is to avoid interfering with any programs that might use these names for other things.

Functions which would normally be built in but do not have semantics defined by ISO C (such as alloca and ffs) are not built-in functions with -ansi is used. See Other built-in functions provided by GCC, for details of the functions affected.

Jim