C++ 成员函数（getters）

Question

I've seen people define a member function like this:

void getValue(int& v)
{
    v = m_value;
}

and also like this:

int getValue()
{
    return m_value;
}

I guess the first saves memory? Is that the only time you would use the first type of get-function? The second seems a lot more convenient.

Answer 1

I thought I would godbolt it for you

source

#include <iostream>
struct Foof{
    int m_val;

   Foof(int v){
      m_val = v;
}

void woodle()
{
    if(m_val > 42)
       m_val++;
    else
       m_val--;
      
}
void Get1(int &v)
{
    v = m_val;
}

int Get2()
{
    return m_val;
}
};

int main(int c, char**v){
    int q;
    std::cin >> q;
    Foof f1(q);
    std::cin >> q;
    Foof f2(q);

    f1.woodle();
    f2.woodle();
    int k;
    f1.Get1(k);

    int j = f2.Get2();
    std::cout << k << j;
}

the woodle function and the cin to initialize is to make the compiler think a bit

I have 2 foofs otherwise the compiler goes "well I know the answer to this question" when I call Get2 after Get1

compiled with -03 - ie optimize hard. The code comes out as (gcc)

 pushq %rbx
  movl $_ZSt3cin, %edi
  subq $16, %rsp
  leaq 12(%rsp), %rsi
  call std::basic_istream<char, std::char_traits<char> >::operator>>(int&)
  movl 12(%rsp), %ebx
  leaq 12(%rsp), %rsi
  movl $_ZSt3cin, %edi
  call std::basic_istream<char, std::char_traits<char> >::operator>>(int&)
  movl 12(%rsp), %eax
  movl $_ZSt4cout, %edi

  leal 1(%rbx), %edx
  cmpl $43, %ebx
  leal -1(%rbx), %esi
  cmovge %edx, %esi
  leal -1(%rax), %ebx
  leal 1(%rax), %edx
  cmpl $43, %eax
  cmovge %edx, %ebx

  call std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
  movq %rax, %rdi
  movl %ebx, %esi
  call std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
  addq $16, %rsp
  xorl %eax, %eax
  popq %rbx
  ret

I separated out the actual calls to Get1 or Get2 you can see that

• the generated code is identical
• the compiler is very aggressive at optimizing, there are no function calls etc

Lesson, write your code to be human readable and let the compiler do the heavy lifting