Hola.
Tengo una duda que deseo evacuarla ahora porque me impide seguir estudiando y es: como se pasan los vectores de punteros a las funciones.

void ingreso( char *ptrFrases );

void ingreso( char ptrFrases[] );

int main( void ){
	char *ptrFrases = NULL;
 
	ingreso( ptrFrases );
	ordenar( ptrFrases );
	mostrar( ptrFrases );
 
	return 0;
}
 

Dejo el programa por si les hace falta para interpretar mejor la duda, luego tengo que continuar consultándolos porque la siguiente linea sé que estoy haciendo todo mal pero es la primera vez que lo intento y realmente no logro solucionarlo, hacer lo mismo con números me funciona a la perfección, en cambio, con cadenas no. -

tmp = (char*)realloc( ptrFrases+i, CARACTERES * sizeof(char) );
	if( tmp!=NULL ){
		strcpy( ptrFrases[i-1], tmp );
	}
 

#include <stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define CARACTERES 21
#define safeFree(p) saferFree((void**)&(p))
 
void ingreso( char *ptrFrases );
void vaciarBuffer( char tmp[] );	
void ordenar( char *ptrFrases );
void mostrar( char *ptrFrases );
void saferFree( void **pp );
 
int main( void ){
	char *ptrFrases = NULL;
 
	ingreso( ptrFrases );
	ordenar( ptrFrases );
	mostrar( ptrFrases );
 
	return 0;
}
 
 
void ingreso( char *ptrFrases ){
	int i = 0, ok, opc;
	char tmp[CARACTERES], ch;
 
	while( 1 ){
		printf( "\n Ingrese una palabra(maximo %d caracteres).....:", CARACTERES-1 );
		fgets( tmp, CARACTERES, stdin );
		vaciarBuffer( tmp );	
 
		do{
			printf( "\n 1 - Ingresa otra frase\n 0 - Finalisa\n Ingrese opcion...: " );
			ok = scanf( "%d", &opc ) == 1 && opc >= 0 && opc <=1;
			while ((ch = getchar()) != EOF && ch != '\n'); 
		}while( !ok );
		if( opc == 0){
			break;	
		}
		i++;
		tmp = (char*)realloc( ptrFrases+i, CARACTERES * sizeof(char) );
		if( tmp!=NULL ){
			strcpy( ptrFrases[i-1], tmp );
		}
		else{
			safeFree( ptrFrases );
			puts( "Error (re)allocating memory" );
			exit(1);
		}
	}	
 
}
 
void vaciarBuffer( char tmp[] ){
	char *p = NULL;
	size_t ch;
 
	if((p=strchr(tmp, '\n'))){
		*p='\0';
	}
	else{
		while((ch = getchar()) !='\n' && ch!=EOF);
	}			
}
 
void saferFree(void **pp) {
	if (pp != NULL && *pp != NULL) {
		free(*pp);
		*pp = NULL;
	}
}
 
void ordenar( char *ptrFrases ){
	printf( "\n No desarrollado" );	
}
void mostrar( char *ptrFrases ){
	printf( "\n No desarrollado" );	
}
 

Saludos y gracias. -

Hola, Alberto. -
Muchas gracias amigo funciona a la perfección, pero igual me queda una duda y es que al tener un espacio creado con:

strcat( arr, " ");

¿no debería reservar un espacio más?  

size_t totCarac = strlen( origUno ) + strlen( origDos ) + 1;

Un abrazo.

Hola, gente.
Les quito un poco de tiempo porque si bien estoy leyendo que es lo que causa el doble free no logro solucionarlo por mí mismo y si lo lograra me quedarían dudas en la función concatenar, les digo esto porque si bien logre que no me diera error en la compilación lo hice a fuerza de prueba/error/solución pero no teniendo claro que es lo que estaba haciendo. -
Las cosas que no me quedan claras:

1): Porque debo hacer que la función se declare como un puntero a función.
2): Porque el error del doble free.
3): Como se hace para poner un espacio entre las dos frases (por programación, claro).-
  

#include <stdio.h>
#include<string.h>
#include<stdlib.h>
 
#define MAX 51
 
void ingreso( char origUno[], char origDos[] );
void limpiarBuffer( char cadena[] );
char *concatenar( char *origUno, char *origDos );
 
int main( void ){
	char origUno[MAX] = "", origDos[MAX] = "", *ptrConc = NULL;
 
	ingreso( origUno, origDos );		
	ptrConc = concatenar( origUno, origDos );
 
	printf("\n %s", ptrConc);
 
	free(ptrConc);
 
	return 0;
}
 
void ingreso( char origUno[], char origDos[] ){
 
	printf( "\n Ingrese una frase(maximo %d caracteres)............:", MAX-1 );
	fgets(origUno, MAX, stdin);
	limpiarBuffer( origUno );
 
	printf( "\n Ingrese frase a concatenar (maximo %d caracteres)..:", MAX-1 );
	fgets(origDos, MAX, stdin);
	limpiarBuffer( origDos );
}
 
void limpiarBuffer( char cadena[] ){
	char *p = NULL;
	size_t ch;
 
	if((p=strchr(cadena, '\n'))){
		*p='\0';
	}
	else{
		while((ch = getchar()) !='\n' && ch!=EOF);
	}	
}
 
char *concatenar( char *origUno, char *origDos ){
	size_t totCarac = strlen( origUno ) + strlen( origDos ) + 1;
	char *arr = ( char* )malloc( totCarac * sizeof(char) ); 
	arr = strcat( origUno, origDos ); 
 
	return arr;
}
 

Saludos y desde ya muchas gracias. -

Hola. -
Tiene toda la razón, lo que ocurre es que el tema que estoy estudiando es matriz de punteros de una dimensión. y para el caso me parece que vale el Ej. que saque del libro, igual me viene de maravilla porque no se si me hubiera dado cuenta por mí mismo de tu alternativa, una muy buena aclaración. -

Saludos.

Hola, gente.
Tengo una pequeña duda con él programara que dejo a continuación y es si esta bien liberada la memoria. -

/*
 matriz de punteros de una dimensión. 
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define MAX 5
 
int main(void) {
	int *arr[MAX], i;
	srand(time(NULL));
 
	for( i=0; i<MAX; i++ ){
		*(arr+i) = (int*)malloc(sizeof(int));
		**(arr+i) = rand() % 100;
		printf( "\n %d", **(arr+i) );
	}
	for( i=0; i<MAX; i++ ){
		free(*(arr+i));
	}
 
 
	return 0;
 
}

Si tienen tiempo y lo desearían necesitaría un poco de teoría al respecto si esta mal como si estuviera bien. -
Saludos y desde muchas gracias como siempre.-

Hola, geeke.
Muchas gracias por ocuparte, las dudas que me quedan ahora son las siguientes:
Si recibo en a la función el arreglo de esta manera

         void vector_(int vector[] );

¿En la función se crearía una copia de todo el arreglo?
Y la otra es, si tendrían un arreglo con 1000 elementos, ¿de qué manera llamarían a la función y como lo recibirían?.-

Saludos.

Hola, fary.
Muchas gracias por ocuparte.-

Saludos.

Hola, gente.
Les dejo un ejemplo de lo que digo en el enunciado y la pregunta es ¿hay alguna diferencia en hacerlo de una manera u otra?, los consulto porque me parece que en ningún Ej. vi como lo hago en la segunda llamada a la función. -

#include <stdio.h>
 
void vector_(int *vt );
 
int main(void) {
	int vector[] = {1, 2, 3, 4, 5}, *vt = vector;
 
	vector_(vt);
	printf( "\n" );
	vector_(vector);
 
	return 0;
 
}
 
 
void vector_(int *vt ){
	size_t i;
	for( i=0; i<5; i++){
		printf("\n %d", *(vt+i));	
	}
}
 

Saludos.

Hola, amigos. -
La duda es ¿debo liberar la memoria con un bucle o simplemente liberar el primer puntero?, lo que me sucede es que no me da ningún error, pero no tengo manera de comprobar si esto es correcto, por lo menos por mis escasos conocimientos de memoria dinámica desconozco cómo podría comprobarlo. -   
Con el barullo que tengo de tantas cosas nuevas no sé si logro hacerme entender, valga el intento. -

#include <stdio.h>
#include <stdlib.h>
 
#define safeFree(p) saferFree((void**)&(p))
 
void ingreso( void );
void imprimir( int numeros[], size_t contador );
void saferFree( void **pp );
 
int main( void ){
 
	ingreso();
 
	return 0;	
}
 
 
void ingreso( void ){
	size_t contador=0, ingreso, ch, ok;
	int *numeros=NULL, *tmpNumeros=NULL;	
 
	do{
		do{
			printf( "\n Ingrese un numero [0 para finalizar]....:");
			ok = scanf( "%lu", &ingreso ) == 1 && ingreso >=0;
			while( (ch = getchar()) != '\n' && ch != EOF ); 
		}while( !ok );
 
		contador++;
		tmpNumeros = (int *)realloc( numeros, contador * sizeof(int) );	
		if( tmpNumeros != NULL ){
			numeros = tmpNumeros;
			numeros[contador-1] = ingreso;	
		}
		else{
			safeFree( numeros );
			puts( "Error en asignar memoria....." );
			exit(1);	
		}
 
	}while( ingreso >= 1 );
 
	imprimir( numeros, contador );
	safeFree( numeros );
}
 
void imprimir( int numeros[], size_t contador ){
	size_t i;
 
	for(i=0; i<contador-1; i++){
		printf( "\n %d", numeros[i] );	
	}
}
 
void saferFree(void **pp) {
	if (pp != NULL && *pp != NULL) {
		free(*pp);
		*pp = NULL;
        }
}

Debo aclarar que el código es casi todo mío por eso no puedo averiguarlo en el libro con el que estoy estudiando. -
Saludos.

Hola, mucha gracia a ambos por ocuparse. -
Me queda todo muy claro, el identificador del array se pasa por valor y como la función llamada recibe una copia exacta de la dirrección del primer elemento del array, toda modificación que se efectúe en dicha función se ve reflejada en el array original. -
Voy a agregar que los elementos del array individualmente se pasan por valor, les dejo este Ej. de Eternal Idol (que encontré en el foro) para pasarlos por referencia. -

#include <stdio.h>
 
int Valor(int);
int Referencia(int*);
 
int main(void)
{
    int array[30];
    array[4] = 33;
 
    printf("Posicion 5, Valor: %d\r\n", Valor(array[4]));
    printf("Posicion 5, Valor: %d\r\n", array[4]);
    printf("Posicion 5, Referencia %d\r\n", Referencia(&array[4]));
    printf("Posicion 5, Referencia %d\r\n", array[4]);
 
    return 0;
}
 
int Valor(int v)
{
  return v;
}
 
 
int Referencia(int *r)
{
  return (*r)++;
}

Saludos.