CODEWITHSUNDEEP
c++classmemorymemory-managementmethods
Matthew D. Scholefield
Matthew D. Scholefield

Reputation: 3346

What uses more memory in c++? An 2 ints or 2 functions?

I am writing in c++ for the Nintendo DS (With 4MB of RAM). I have a button class that stores data like the x,y location and length. Which of the following would take less memory?

.

Method 1, class variables length, x, y, and halfPoint

Button::Button(int setX, int setY, int setLength)
{
    x = setX;
    y = setY;
    length = setLength;
    halfPoint = length/2;
}
//access variable with buttonName.halfPoint

Method 2, class variables length, x and y

Button::Button(int setX, int setY, int length)
{
    x = setX;
    y = setY;
    length = setLength;
}

int Button::getHalfPoint()
{
    return length/2;
}
//access variable with buttonName.getHalfPoint()

Any help is appreciated. (And in the real code I calculate a location much more complex than the half point)

Upvotes: 3

Views: 198

Answers (3)

Thomas Matthews
Thomas Matthews

Reputation: 57698

I suggest you declare the getHalfPoint method inside your class. This will make the compiler inline the code.

There is a possibility that the code in the function is one assembly instruction, and depending on your platform, take the size of 4 bytes or less. In this case, there is probably no benefit to have a variable represent the half of another variable. Research "right shifting". Also, to take full advantage, make the variable unsigned int. (Right shifting a signed integer is not defined.)

The inline capability means that the content of the function will be pasted wherever there is a call to the function. This reduces the overhead of a function call (such as the branch instruction, pushing and popping arguments). The reduction of a branch instruction may even speed up the program because there is no flushing of the instruction cache or pipeline.

Upvotes: 1

Cameron
Cameron

Reputation: 98756

Well, that depends!

The method code exists exactly once in memory, but a member variable exists once for each object instance.

So you'll have to count the number of instances you create (multiplied by the sizeof the variable), and compare that to the size of the compiled method (using a tool like e.g. objdump).

You'll also want to compare the size of your Button with and without the extra variable, because it's entirely possible that the compiler pads it to the same length anyway.

Upvotes: 2

George Hilliard
George Hilliard

Reputation: 15942

The getHalfPoint() method will take up less room if there are a lot of Buttons. Why? Because member functions are actually just implemented by the compiler as regular functions with an implied first argument of a pointer to the object. So your function is rewritten by the compiler as:

int getHalfPoint(Button* this)
{
    return this->length/2;
}

(It is a bit more complicated, because of name mangling, but this will do for an explanation.)

You should carefully consider the extra amount of computation that will have to be done to avoid storing 4 extra bytes, however. And as Cameron mentions, the compiler might add extra space to the object anyway, depending upon the architecture (I think that is likely to happen with RISC architectures).

Upvotes: 2

Related Questions