Как на самом деле функция возвращает значение?

Разница в том, что в случае g вы возвращаете значение, которое было передано функции. В стандарте явно указано, при каких условиях копия может быть удалена в 12.8p31, и он не включает исключение копии из аргумента функции.

В основном проблема заключается в том, что расположение аргумента и возвращаемого объекта фиксируется соглашением о вызовах, и компилятор не может изменить соглашение о вызовах на основании того факта, что реализация (которая может быть даже не видна в месте вызова) возвращает аргумент.

Некоторое время назад я завел недолговечный блог (ожидал, что у меня будет больше времени...) и написал пару статей о NRVO и копировании, которые могут помочь прояснить это (или нет, кто знает :)):

Семантика значений: NRVO

Семантика значений: исключение копирования

Проблема в том, что во втором случае вы возвращаете один из параметров. Учитывая, что обычно копирование параметра происходит на месте вызывающей стороны, а не внутри функции (в данном случае main), компилятор делает копию, а затем вынужден копировать ее снова, как только он входит в g().

Из http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/

Во-вторых, мне еще предстоит найти компилятор, который пропускал бы копию при возврате параметра функции, как в нашей реализации sorted. Когда вы думаете о том, как выполняются эти исключения, это имеет смысл: без какой-либо формы межпроцедурной оптимизации вызывающая сторона sorted не может знать, что аргумент (а не какой-либо другой объект) в конечном итоге будет возвращен, поэтому компилятор должен выделить отдельное место в стеке для аргумента и возвращаемого значения.

Вот небольшая модификация вашего кода, которая поможет вам прекрасно понять, что там происходит:

class A{
public:
    A(const char* cname) : name(cname){
        std::cout << "constructing " << cname << std::endl;
    }
    ~A(){
        std::cout << "destructing " << name.c_str() << std::endl;
    }
    A(A const& a){
        if (name.empty()) name = "*tmp copy*";
        std::cout 
            << "creating " << name.c_str() 
            << " by copying " << a.name.c_str() << std::endl;
    }
    A& operator=(A const& a){
        std::cout
            << "assignment ( "
                << name.c_str() << " = " << a.name.c_str()
            << " )"<< std::endl;
        return *this;
    }
    std::string name;
};

Вот использование этого класса:

const A f(A x){
    std::cout 
        << "// renaming " << x.name.c_str() 
        << " to x in f()" << std::endl;
    x.name = "x in f()";
    A y("y in f()");
    return y;
}

const A g(A x){
    std::cout 
        << "// renaming " << x.name.c_str()
        << " to x in f()" << std::endl;
    x.name = "x in g()";
    A y("y in g()");
    return x;
}

int main(){
    A a("a in main()");
    std::cout << "- - - - - - calling f:" << std::endl;
    A b = f(a);
    b.name = "b in main()";
    std::cout << "- - - - - - calling g:" << std::endl;
    A c = g(a);
    c.name = "c in main()";
    std::cout << ">>> leaving the scope:" << std::endl;
    return 0;
}

и вот вывод при компиляции без какой-либо оптимизации:

constructing a in main()
- - - - - - calling f:
creating *tmp copy* by copying a in main()
// renaming *tmp copy* to x in f()
constructing y in f()
creating *tmp copy* by copying y in f()
destructing y in f()
destructing x in f()
- - - - - - calling g:
creating *tmp copy* by copying a in main()
// renaming *tmp copy* to x in f()
constructing y in g()
creating *tmp copy* by copying x in g()
destructing y in g()
destructing x in g()
>>> leaving the scope:
destructing c in main()
destructing b in main()
destructing a in main()

Опубликованный вами результат — это результат работы программы, скомпилированной с помощью оптимизации именованного возвращаемого значения. В этом случае компилятор пытается устранить избыточные вызовы конструктора копирования и деструктора, что означает, что при возврате объекта он попытается вернуть объект, не создавая его избыточную копию. Вот вывод с включенным NRVO:

constructing a in main()
- - - - - - calling f:
creating *tmp copy* by copying a in main()
// renaming *tmp copy* to x in f()
constructing y in f()
destructing x in f()
- - - - - - calling g:
creating *tmp copy* by copying a in main()
// renaming *tmp copy* to x in f()
constructing y in g()
creating *tmp copy* by copying x in g()
destructing y in g()
destructing x in g()
>>> leaving the scope:
destructing c in main()
destructing b in main()
destructing a in main()

В первом случае *tmp copy* путем копирования y in f() не создается, так как NRVO выполнил свою работу. Однако во втором случае NRVO не может быть применен, потому что в этой функции был объявлен другой кандидат на слот возврата. Для получения дополнительной информации см.: C++: избежание копирования с помощью оператора return :)

он может (почти) оптимизировать весь вызов функции g(), и в этом случае ваш код будет выглядеть так:

A a;
A c = a;

как эффективно это то, что делает ваш код. Теперь, когда вы передаете a как параметр по значению (т.е. не ссылку), то компилятор почти должен выполнить копию там, а затем он возвращает этот параметр по значению, он должен выполнить еще одну копию.

В случае f(), поскольку он возвращает то, что фактически является временным, в неинициализированную переменную, компилятор может видеть, что безопасно использовать c в качестве хранилища для внутренней переменной внутри f().