Lo estas haciendo mal. Deberia ser:

void llenar(int ptrnumeros[])
{
   ptrnumeros[0] = 25;
   ptrnumeros[1] = 50;
}
 
int main()
{
   int numeros[2];
 
   llenar(numeros);
   printf("%d %d\n", numeros[0], numeros[1]);
 
   return 0;
}

Y deberías evitar el uso de funciones como getch parte de la biblioteca conio de Borland, las razones de ello se encuentran en el tema |Lo que no hay que hacer en C/C++. Nivel basico|.

Un saludo

Creo que he encontrado la solución: No era una sola cosa sino varias, en cuestión todo con los benditos/malditos punteros.

Lo primero que estabas haciendo al hacer referencia a los elementos del arreglo está mal, la forma de hacerlo es incrementando la dirección de memoria con aritmética de punteros.

Lo segundo es la forma en que llamas a la función al pasar el parámetro no utilices el operador "&". El código que a mí me compiló (haciendo la aclaración: como código C no C++ por el uso de getch() ) es el siguiente.

void llenar(int *ptrnumeros)
  {
      *ptrnumeros=25;
      ptrnumeros++;
      *ptrnumeros=50;
  }
 
void main()
  {
     int numeros[2];
 
     llenar(numeros);
     printf("%d, %d ",numeros[0],numeros[1]);
 
     getch();
   }

Saludos.

Es que sí se le están asignando los valores:

*ptrnumeros=25;
      ptrnumeros++;
      *ptrnumeros=50;

¿Al ejecutar tu aplicación qué valores te aparecen?

Si tu estás gestionando punteros... y un vector lo es, cualquier cambio en el puntero es visible para todos los punteros que apunten a la misma posición de memoria.

cuando tú pasas como argumento de una función un vector no estás copiando literalmente ese vector, estás pasando la posición de memoria en la cual "empieza" dicho vector... o lo que es lo mismo, estás pasando un puntero.

Cualquier cambio que realices en la memoria apuntada por ese puntero se verá reflejado en el vector, ya que ambos elementos están trabajando sobre la misma posición de memoria.

Por cierto yookino, en el otro foro donde habías puesto la pregunta te puse una respuesta más detallada sobre el (sutils) asunto aquí desarrollado. Era esta:

===========================================================
Aparte del error en el printf, tu programa tiene un problema muy sutil, justo de esa clase que los hace difíciles de localicar. Una de las mayores potencias del lenguaje C es la capacidad de manejar punteros, pero esa ventaja se puede convertir a veces en dolor de cabeza.

La función llenar está codificada de manera de recibir un arreglo de punteros. Aquí debes tener en cuenta la "precedencia" de los operadores de C, pues el operador [] (acceso a elemento arreglo) tiene mayor precedencia que el operador * (indirección). O sea, que la sentencia:


*ptrnumeros[0]=25;


primero ejecuta el "[]", luego el "*". O sea, extrae el primer elemento del arreglo prtnumeros, que debe ser un puntero (o sea, la dirección de un dato en la memoria), y luego obtiene el dato apuntado por dicha dirección.

Ahora, bien, en la sentencia


llenar(&numeros);


no estás pasando un arreglo de punteros sino un arreglo por referencia (que es otra cosa). Si fueras a hacer eso, la función llenar debería esta codificada más bien como:


(*ptrnumeros)[0]=25;


que PRIMERO convierte la dirección al arreglo en un arreglo, y luego accesa a su elemento. Ahí debería funcionar sin problemas.

Los arreglos de punteros se usan por ejemplo para crear matrices bidimensionales y la verdad no tiene nada que ver con tu ejercicio. Para tu caso yo recomendaría una solución más senclla, como:


Puesto que en C un arreglo es un puntero (al primer elemento del array), "numeros" es a la vez un arreglo de int, y un puntero a int. Con esto debería funcionar perfectamente, no se por qué te fuiste por una solución tan complicada.

Espero te ayude  
Yoel.