Puede ser porque tengas abiertas dos ventanas donde estés ejecutando el mismo programa.
Si no es eso, coloca tú código porque no somos adivinos. Suerte

Coloca el resto de tú código para que pueda ver el problema

Imagino que te refieres a usando memoria dinámica. En ese caso el proceso es el siguiente, tanto en una función con parámetros como en el <main>:

int **matriz;
int filas = 4, columnas = 4;
 
matriz = new int* [filas]; // reservamos memoria en el puntero para tantos punteros como filas tenga la matriz
for(int i = 0; i < filas; ++i) // por cada fila
    matriz[i] = new int [columnas]; // reservamos espacio para x columnas
 

También se podría hacer al revés y crear punteros para cada columna y luego reservar filas pero se suele hacer así.
No olvides luego liberar toda la memoria dinámica que hemos reservado... Suerte

Coloca tu código entre etiquetas de código GeSHi

Es una forma de simplificarlo pero en la función <suma_pos_pares()>, el último parámetro creo que sobra completamente (ya que además hacer uso de el puede dar a errores al ser pasado por referencia) y el segundo parámetro también lo quitaría y que devuelva la suma la propia función. Imagina que usas la función esa 3 veces y olvidas poner el contador a 1 y la suma a 0 antes de cada ejecución; la primera ejecución sería correcta pero las dos siguientes, no.
Además la idea del contador para coger solo las posiciones pares funciona bien cuando lo piensas pero complica un poco más el código.

Para sumar las posiciones pares de un número, ¿qué necesitas saber? El número. Suficiente. Entonces podemos dejarlo así:

int sumarPosicionesPares(int numero){
    int suma = 0;
    while(numero != 0){
        numero /= 10;
        suma += numero % 10;
        numero /= 10;
    }
    return suma;
} 

Tienes razón en esto. Fue fallo mío que pensé en asignarle NULL pero lo olvidé al estar pensando en el resto de la explicación
Además no conocía la diferencia entre <NULL> y <nullptr> así que gracias también por ello.

Por lo que he leído yo es porque <NULL> equivale a un 0 de tipo <int>; mientras que <nullptr> equivale a 0 también (si muestras el valor puedes verlo) siempre sigue siendo de tipo puntero, como dice @Loretz es de tipo <nullptr_t>. Entonces se evita el uso de <NULL> porque puede dar errores de ambigüedad al cambiar el tipo de dato.

Es cierto que sus posiciones de memoria deben diferir en el tamaño del tipo de dato que puede almacenar. Pero como comenté, uso posiciones de memoria consecutivas y simples ya que lo que quería que se entendiese era ver de qué posiciones de memoria estamos hablando en cada momento.

Gracias por la respuesta ya que me diste la idea de probar el mismo programa para ver las posiciones de memoria que se utilizan. He añadido otra función para que se vea mejor el paso de un puntero por valor y por referencia.

int main(){
	int *p = nullptr;
	cout << "p esta en " << &p << " y su contenido es " << p << endl;
	reservarMemoria(p,2);
	p[0] = 1;
	cout << "p[0] esta en " << &p[0] << " y su contenido es " << p[0] << endl;
	p[1] = 2;
	cout << "p[1] esta en " << &p[1] << " y su contenido es " << p[1] << endl;
	anular(p,1);
//	cout << "p[1] esta en " << &p[1] << " y su contenido es " << p[1] << endl;
}
 
void reservarMemoria(int *&v, int size){
	cout << "FUNCION RESERVAR MEMORIA (puntero por referencia)" << endl;
	cout << "v esta en " << &v << " y su contenido es " << v << endl;
	v = new int [size];
}
 
void anular(int *v, int pos){
	cout << "FUNCION ANULAR (puntero por valor)" << endl;
	cout << "v esta en " << &v << " y su contenido es " << v << endl;
	v[pos] = 0;
} 

Al ejecutarlo obtenemos la siguiente salida (las posiciones de memoria depende de cada ejecución) donde podemos observar que coinciden los valores que comenté en mi anteior explicación:
En la función <reservarMemoria()> como se pasa el puntero por referencia se ve que la dirección de memoria de <v> (&v) es la misma que la de <p> (&p). Sin embargo en la función <anular()> como se pasa el puntero por valor, la dirección de memoria de <v> (&v) es distinta  a la de <p> (&p) aunque el valor que guardan que es la dirección de memoria de <p[0]> (&p[0]) en ambos casos, sí es la misma.

Algo tan tonto como lo siguiente:

Creo que ya te has dado cuenta del problema no??

Te doy la idea para que le encuentres la utilidad. Hay una utilidad que se usa mucho cuando se trabaja con números de formas similares a esta que es:

int numero = 123456789;
int ultima_cifra = numero % 10; // 9
numero /= 10; // 12345678 

Ahora puedes adaptar esta idea a tu necesidad.
Si te surge algún problema, envía tu código para que podamos ver dónde falla. Suerte

Eso lo puedes solucionar con un <while> de forma bastante sencilla, el esquema sería el siguiente:

// pides un numero
while(numero != 0){
    // haces lo que tengas que hacer con ese numero
    // pides otro numero
} 

AQUÍ te dejo un enlace donde aparece un problema muy similar al tuyo.
Bueno más que similar es el mismo... Así que la respuesta es la misma también.

Y te recomiendo que no sigas abriendo temas nuevos para el mismo problema, si quieres responde en el que ya está creado para que no tengan que estar luego borrando temas repetidos. O especificas qué duda tienes o colocas tu código para ver cómo podemos ayudar. El programa no te lo vamos a dar hecho. Suerte 

Después de darle unas cuántas vueltas creo que he llegado a una explicación. Si alguien ve algo raro o incorrecto que me lo comente para corregirlo ya que creo que puede servir para gente que tenga dudas con esto
Voy a usar un ejemplo muy sencillo para explicar esto:

void anular(int *v, int pos){
    v[pos] = 0;
}
 
int main(){
    int *p;
    p = new int [2];
    p[0] = 1;
    p[1] = 2;
    anular(p,1);
} 

En la línea 6, declaramos un puntero (almacena una dirección de memoria) <p> y hacemos que apunte a <NULL>. Vamos a suponer que se guarda en la posición de memoria 0x1 (voy a usar posiciones de memoria consecutivas para simplificar el ejemplo). Entonces quedaría así:

---

En la línea 7, reservamos memoria para guardar dos enteros. Suponemos que sus posiciones son 0x2 y 0x3 respectivamente y en las líneas 8 y 9 asignamos valores a esas posiciones. Entonces tenemos:

---

En la línea 10, llamamos a la función <anular()>, la cual recibe el puntero que almacena la dirección de memoria del primer elemento del array. Al ser pasado por valor, se copia el contenido de <p> en <v> (suponemos <v> en 0x4) y el 1 se copia en <pos> (suponemos 0x5). Entonces tenemos antes de ejecutar la función:

---

Al ejecutar la línea 2, el contenido se modifica en el "array original" (que es siempre el mismo porque sólo tenemos uno). Esto es porque <v> almacena la misma posición de memoria que <p> (OJO: <v> no almacena la posición de memoria dónde se guarda <p>, sino la dirección de memoria que se guarda EN <p>).
Por eso para hacer cambios o acciones sobre el array en sí, no es necesario pasarlo por referencia, porque ambos punteros apuntan al mismo sitio.

---

Sin embargo, si tenemos esta alternativa:

void reservar(int *&v, int size){
    v = new int [size];
} 

Y queremos reservar memoria, esto es una operación que se debe aplicar, siguiendo con el mismo ejemplo, sobre 0x1 (dirección en la que hemos guardado <p>), no sobre 0x4 (dirección en la que hemos guardado <v>). Al pasar por referencia la tabla de direcciones de memoria anterior quedaría de la siguiente manera:
Y entonces ahora sí que podemos aplicar la orden de reserva sobre <v> ya que en realidad la estamos aplicando sobre <p> (realmente se lo estamos aplicando a la dirección 0x1).

Entonces mi conclusión es que el paso por referencia es para operar sobre la dirección de memoria DÓNDE está el puntero, no para operar sobre la dirección de memoria que está EN el puntero. Por lo que supongo que a efectos de "eficiencia", es lo mismo hacer un paso por referencia que por valor (en ambos casos pasamos únicamente una dirección de memoria, en un caso la dirección dónde está el puntero y en el otro, la dirección que guarda el puntero)

Espero que le sirva a alguien.