Puntero de retorno de una función en Go

Requisito previo: punteros en Go y pasar punteros a la función

Los punteros en el lenguaje de programación Go o Golang es una variable que se utiliza para almacenar la dirección de memoria de otra variable. Podemos pasar punteros a la función, así como devolver punteros desde una función en Golang. En C / C++ , no se recomienda devolver la dirección de una variable local fuera de la función, ya que queda fuera del alcance después de que la función regresa. Entonces, para ejecutar el concepto de devolver un puntero desde una función en C/C++, debe definir la variable local como una variable estática.

Ejemplo: en el siguiente programa, la línea de código ( int lv = n1 * n1; ) dará una advertencia ya que es local para la función. Para evitar advertencias, hágalo estático.

// C++ program to return the
// pointer from a function
#include <iostream>
using namespace std;
  
// taking a function having
// pointer as return type
int* rpf(int);
  
int main()
{
  
    int n = 745;
  
    // displaying the value of n
    cout << n << endl;
  
    // calling the function
    cout << *rpf(n) << endl;
}
  
// defining function
int* rpf(int n1)
{
  
    // taking a local variable
    // inside the function
    int lv = n1 * n1;
  
    // remove comment or make the above
    // declaration as static which
    // result into successful
    // compilation
    // static int lv = n1 * n1;
  
    // this will give warning as we
    // are returning the address of
    // the local variable
    return &lv;
}

Advertencias

prog.cpp: en la función ‘int* rpf(int)’:
prog.cpp:24:9: advertencia: dirección de la variable local ‘lv’ devuelta [-Wreturn-local-addr]
int lv = n1 * n1;

Producción:

745

La razón principal detrás de este escenario es que el compilador siempre crea una pila para una llamada de función. Tan pronto como la función sale, la pila de funciones también se elimina, lo que hace que las variables locales de las funciones queden fuera del alcance. Hacerlo estático resolverá el problema. Como las variables estáticas tienen la propiedad de conservar su valor incluso después de que estén fuera de su alcance.

¡ Pero el compilador Go es muy inteligente! . No asignará la memoria en la pila a la variable local de la función. Asignará esta variable en el montón. En el siguiente programa, la variable lv tendrá la memoria asignada en el montón, ya que el compilador Go realizará un análisis de escape para escapar de la variable del ámbito local.

Ejemplo:

// Go program to return the
// pointer from the function
package main
  
import "fmt"
  
// main function
func main() {
  
    // calling the function
    n := rpf()
  
    // displaying the value
    fmt.Println("Value of n is: ", *n)
  
}
  
// defining function having integer
// pointer as return type
func rpf() *int {
  
    // taking a local variable
    // inside the function
    // using short declaration
    // operator
    lv := 100
  
    // returning the address of lv
    return &lv
}

Producción:

Value of n is:  100

Nota: Golang no proporciona soporte para la aritmética de punteros como C/C++. Si lo realiza, el compilador arrojará un error como operación no válida.