Class and dinamyc memory

[ar2007]

In this simple exercise, for the "test" of type boolean, I used the variable k = sizeof (data) / sizeof (data [0]), the problem lies in the fact that the dynamic memory k is always equal to 1 . Why?

Thanks on advance.

  #include <iostream>
#include <math.h>
using namespace std;
 
 
int size = 1;
 
// const int size = 10;
 
class parity
  {
    private:
            int  count;
            int  k;
            int* data = new (nothrow) int[size];
            // int data[ size ];
      
    public: 
            explicit parity();// constructor
            void put();       // this function count the number of elements on the array data[]
            bool test();      // this function control if the number of elements is even
            void printer();   // output to screen
   };     
    
    
inline parity::parity()
  {
    count = 0;
    k = 0;
   };
 
inline void parity::put()  // 
  {
    int item = 1;
    while( item != 0 )
      {
        cout << " input new element " << endl;
        cin >> item;
        
        if ( item != 0 )
          {          
            data[count] = item;
            count++;
          }
       }
    k = sizeof( data ) / sizeof( data[ 0 ] );
  };
 
    
    
inline bool parity::test()
  {
    return ( k % 2 != 0 ? 0 : 1 );
   };
 
    
    
inline void parity::printer()
  {
    for ( int i = 0; i < count; i++)
      { 
        cout << " data[ " << i << " ] = " << data [ i ] << " k = " << k << endl;
       }
   };
 
    
    
int main() {
  
  class parity a;
 
  a.put();
      switch ( a.test() )
      {
        case 0:
             cout << " number item is even " << endl;
             break;
        
        case 1:
             cout << " number item is odd " << endl;
             break;
        
        default:
             cout << " zero item " << endl;
      }
  
  a.printer();
  
  return 0;
}

[Disch]

sizeof(a_pointer) gives you the size of a pointer... not the size of the data the pointer points to. This is different from sizeof(an_array) which gives you the size of an array.

Dynamically allocated memory ('data' in your example) is accessed through a pointer. So when you say sizeof(data) you are getting sizeof(int*) which is useless for what you're trying to do.


This is one of the reasons why sizeof() is a bad approach for finding array dims. Not only does it not work for dynamic arrays but it also does not give you a compiler error when used incorrectly like the above... leading to runtime bugs that are harder to find.



Possible solutions to your problem:

1 (recommended): Use a vector rather than managing the memory yourself. In addition to eliminating memory leaks (which you currently have because you never delete[] your array), it also has a proper copy ctor and assignment operator so you don't have to write your own (which, for your class you would or else your program will not work correctly if you try to copy parity objects). AND it has a built-in size() method so you don't have to do sizeof() tricks.

or

2: Keep a separate 'size' variable which keeps track of the size of allocated memory. Use that rather than using sizeof()

[Catfish4]

Well, since I took the time to write this I'll post it anyway.

k is not "dynamic memory". k is a pointer.

A pointer is a variable that holds a memory address (which is a number). On some machines it happens that the size of a pointer equals the size of an integer.

Your trick works with arrays, where sizeof array gives how many total bytes the array contains, and by dividing by how many bytes an element of the array requires sizeof array[0], you get the length of the array. But that trick doesn't work with pointers.

[ar2007]

@disch

In addition to eliminating memory leaks (which you currently have because you never delete[] your array)

can explain why in general, we have memory leaks, during the execution of the program?


@catfìsh
apologizes. dynamic memory was referring to the vector data. I expressed myself badly

[Disch]

can explain why in general, we have memory leaks, during the execution of the program?

new allocates heap memory. That memory stays allocated until you explicitly tell the machine you're done with it by delete-ing it. If you do not delete it... the memory stays allocated for at least the lifetime of the entire program.

If you do this repeatedly, your program will suck up more and more and more memory over time. Therefore it's good practice to delete memory when you're done with it... or better yet... use smart pointers and containers to manage the memory for you so that it is automatically deleted when you're done with it.

[ar2007]

Thanks you disch and cath for the explanations.