Devolviendo este puntero desde una función

Question 1

Estoy tratando de devolver un puntero de una función. Pero estoy recibiendo una falla de segmentación. Alguien por favor diga qué está mal con el código

#include <stdio.h>

int *fun();

main()
{
    int *ptr;
    ptr = fun();
    printf("%d", *ptr);
}

int *fun()
{
    int *point;
    *point = 12;
    return point;
}

Question 2

Asigne memoria antes de usar el puntero. Si no asigna memoria *point = 12 es un comportamiento indefinido.

int *fun()
{
    int *point = malloc(sizeof *point); /* Mandatory. */
    *point=12;  
    return point;
}

También tu printf Está Mal. Necesita desreferenciar (*) el puntero.

printf("%d", *ptr);
             ^

Question 3

Aunque devolver un puntero a un objeto local es una mala práctica, no causó el kaboom aquí. He aquí por qué tienes una falla de segmento:

int *fun()
{
    int *point;
    *point=12;  <<<<<<  your program crashed here.
    return point;
}

El puntero local queda fuera del alcance, pero el verdadero problema es quitar la referencia a un puntero que nunca se inicializó. ¿Cuál es el valor del punto? Quién sabe. Si el valor no se asignó a una ubicación de memoria válida, obtendrá un SEGFAULT. Si por suerte se asignó a algo válido, entonces simplemente corrompiste la memoria al sobrescribir ese lugar con tu asignación a 12.

Dado que el puntero devuelto se usó de inmediato, en este caso podría salirse con la suya devolviendo un puntero local. Sin embargo, es una mala práctica porque si ese puntero se reutilizó después de que otra llamada de función reutilizó esa memoria en la pila, el comportamiento del programa no estaría definido.

int *fun()
{
    int point;
    point = 12;
    return (&point);
}

o casi idénticamente:

int *fun()
{
    int point;
    int *point_ptr;
    point_ptr = &point;
    *point_ptr = 12;
    return (point_ptr);
}

Otra mala práctica pero un método más seguro sería declarar el valor entero como una variable estática, y luego no estaría en la pila y estaría a salvo de ser utilizado por otra función:

int *fun()
{
    static int point;
    int *point_ptr;
    point_ptr = &point;
    *point_ptr = 12;
    return (point_ptr);
}

o

int *fun()
{
    static int point;
    point = 12;
    return (&point);
}

Como han mencionado otros, la forma “correcta” de hacer esto sería asignar memoria en el montón, a través de malloc.

Question 4

No está asignando memoria en la asignación del valor 12 al puntero entero. Por lo tanto, se bloquea, porque no encuentra ninguna memoria.

Puedes probar esto:

#include<stdio.h>
#include<stdlib.h>
int *fun();

int main()
{
    int *ptr;
    ptr=fun();
    printf("\n\t\t%d\n",*ptr);
}

int *fun()
{
    int ptr;
    ptr=12;
    return(&ptr);
}

Question 5

Que yo sepa, el uso de la palabra clave new hace relativamente lo mismo que malloc (tamaño del identificador). El siguiente código demuestra cómo usar la palabra clave new.

    void main(void){
        int* test;
        test = tester();
        printf("%d",*test);
        system("pause");
    return;
}
    int* tester(void){
        int *retMe;
        retMe = new int;//<----Here retMe is getting malloc for integer type
        *retMe = 12;<---- Initializes retMe... Note * dereferences retMe 
    return retMe;
}

¿Ha sido útil esta solución?