When a function returns data in C++, it essentially performs an operation similar to argument passing. Depending on the return type, the compiler manages memory and object lifecycles differently. It is important to note that simply defining a pointer or a reference to an object does not trigger constructor or destructor calls.

Returning by Value

Returning by value involves creating a copy of the data. The compiler generates a temporary object to hold the return value. This temporary object acts as an rvalue; it has no pesristent memory address and cannot be modified directly in the calling expression.

For complex objects, returning by value can be expensive due to the overhead of the copy constructor. However, modern compilers often apply Return Value Optimization (RVO). If RVO is active, the local object is constructed directly in the memory space provided by the caller, eliminating the need for a temporary copy and reducing overhead.

struct DataNode {
    int id;
    double value;
};

DataNode createNode(int n) {
    DataNode localNode = {n, 0.5 * n};
    return localNode; // Potential RVO or copy/move here
}

Returning by Pointer

Functions that return a pointer provide the memory address of an object. The address itself is returned as a value (an rvalue). Unlike returning by value, returning a pointer to a class type does not invoke copy constructors or destructors.

One critical danger is returning the address of a local non-static variable. Since local variables are stored on the stack, they are destroyed when the function exits. The resulting pointer becomes a dangling pointer, leading to undefined behavior if accessed.

// Safe: Returning address of a static variable
int* getSequenceId() {
    static int sequence = 1024;
    sequence++;
    return &sequence;
}

// Unsafe: Returning address of a stack variable
int* calculateFaulty() {
    int temporaryResult = 500;
    return &temporaryResult; // Error: address of local variable returned
}

Guidelines for returning pointers:

• Never return the address of a local stack-based variable.
• You may return the address of static variables as they persist for the lifetime of the program.
• Returning pointers to heap-allocated memory (via new) is valid but shifts the responsibility of memory deallocation to the caller.

Returning by Reference

Returning by reference provides an alias to an existing object. Because it refers to a specific memory location, the returned reference can often be used as an lvalue, meaning it can appear on the left side of an assignment operator.

int& getGlobalStatus() {
    static int statusFlag = 0;
    return statusFlag;
}

int main() {
    getGlobalStatus() = 1; // Modifies the static variable directly
    return 0;
}

Similar to pointers, returning a reference to a local variable is a logic error. Once the function scope ends, the reference refers to an invalid memory location. If the function returns a reference to an object, no copy constructor or destructor is called for that object during the return process.

Returning String Literals

When a function returns a const char* pointing to a string literal (e.g., "Success"), it is returning the address of data stored in the program's read-only data segment. This memory is not cleared when the function returns, making it safe to access.

#include <iostream>

const char* fetchSystemMessage() {
    const char* msg = "SYSTEM_OK";
    return msg; // Safe: points to constant data segment
}

int main() {
    const char* label = fetchSystemMessage();
    std::cout << label << std::endl;
    return 0;
}

In this scenario, the pointer msg stores the starting address of the string constant. When the pointer is returned, the caller receives that fixed address, allowing safe read access throughout the application's execution.