El problema está en que los vectores <pares> e <impares> no están inicializados a 0. Entonces en el <for> como el primer número es impar se guarda en <impares[0]> pero ¿qué queda en pares[0]? basura, es decir, un número desconocido. Siguiente iteración: el 2 es par entonces se guarda en pares[1]; pero... ¿qué hay en impares[1]? basura. Y así hasta el final.

Para que veas lo que te digo si inicializamos los vectores <pares> e <impares> a 0 de esta manera:

int pares[10] = {0};
int impares[10] = {0}; 

Veremos como nos sale el resultado esperado pero intercalando un 0. El 0 sale porque ahora en vez de haber basura hemos llenado el vector de 0. Entonces en cada iteración se guarda el número en un vector y en el otro vector habrá un 0.

PD: Para mejorar un poco más el código, si para saber si es par hacemos:

if(numeros[i]%2==0) 

Cuando es impar? Siempre que no sea par. Por lo tanto con poner el else sin otra condición el programa funciona correctamente y nos ahorramos el segundo <if>.

Ahora puedes pensar como hacer para no ir guardando un 0 en cada posición que te saltas. Pista: usas el índice i para recorrer todos los vectores, pero los vectores <pares> e <impares> no avanzan al mismo ritmo que <numeros> por lo que tendrás que usar índices distintos.

Te ha faltado modificar la siguiente línea:

for(i=0;i=9;i++){ 

El segundo campo de <i = 9> como te hemos comentado antes no es correcto.
Primero: si tu idea era poner como condición que i sea igual a 9, entonces se pone como <i == 9> con dos iguales.
Segundo: en tal caso ese bucle empezaría con <i = 0> y se ejecutaría si <i == 9>, es decir, nunca.
Tercero: fíjate en como has hecho el <for> para recorrer el vector y mostrarlo más abajo.

PD: Si este programa si lo estás haciendo tú te recuerdo lo que te comenté en tus primeros posts. En lugar de "#include <stdlib.h>" utiliza mejor "#include <cstdlib>" aunque el programa va a funcionar igual es más correcto usar las librerías de C++ en vez de las de C. Y en segundo lugar evita usar <system("pause")> como ya te comente es preferible sustituirlo por <cin.get()> a no ser que te obliguen a usar eso en la universidad (si usas <cin.get()> puedes eliminar la librería <cstdlib> ya que en este programa sólo es necesaria para hacer la llamada al sistema <system>.

No, dentro por ejemplo un típico uso del <do while> es para hacer un filtro y que el usuario introduzca un valor válido, para ese caso se hace así:

int main(){
    int numero;
    do{
        cout << "\nIntroduce un numero positivo: ";
        cin >> numero;
   } while(numero < 0);
    // el resto del programa
} 

Así el programa solo pasa de ahí cuando el número es positivo, ya que si es negativo te lo vuelve a pedir. La idea es esa pero dentro del do mete todo lo que tienes que hacer y al final preguntas si desea repetir o no y lo comparas en el while.

Eso se hace con el uso del <do while>. Mete prácticamente todo el programa en un bucle <do> (excepto las dos últimas líneas porque sino acabaría siempre) y añade al final del <do> un par de líneas de código donde le dices al usuario que si desea repetir el programa introduzca "s" o "S", guardas la respuesta del usuario en una variable y la condición del while es que mientras esa variable sea "s" o "S".

La parte de pasar mi explicación a código te lo dejo a ti y si te surge alguna duda puedes volver a preguntar pero recuerda meter el código entre etiquetas pulsando en <Código GeSHi> y eligiendo c++ para que te aparezcan dos etiquetas de código. Mete el código entre esas dos etiquetas y listo.

Veo que programas en C++. Te recomiendo que en vez de <system("pause")> utilices <cin.get()> por buena praxis. Aquí tienes más información sobre ese y otros puntos: https://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html

A lo que se refiere es que si haces <i = 9> estás haciendo una asignación, no una comparación. La comparación se hace con dos iguales <i == 9> como en:

 If(numeros[i] % 2 == 0) 

De todos modos ese for se ejecuta cuando <i == 9> y dudo que eso sea lo que quieres ya que entonces solo se ejecuta para la última posición del vector.

Además donde comparas si es par o impar has puesto la misma condición osea que si es par, hace tal y sino, si es par, hace tal... Osea que el segundo if está mal.

Y en el último for para meter los resultados estás poniendo el primer par, 6 saltos de línea y el primer impar, etc; es decir, imposible de leer (además de que repites el título en cada iteración). Más correcto sería:

cout << "Numeros pares:" 
for(i = 0; i < 10; i++) 
    cout << pares[i] << " "; 

Y lo mismo para los impares.

He notado una ambigüedad en la pregunta, por eso voy a intentar aclararlo. Si introduces <N = 10> y <X = 4> tenemos varios resultados:
- 1 2 3 5 6 7 9 10 11 13 (es decir imprimir N números y que ninguno de ellos sea múltiplo de X)
- 1 2 3 5 6 7 9 (es decir imprimir desde 1 hasta N y que ninguno sea múltiplo de X)
Se nota a simple vista la diferencia, en el primer caso calcular el promedio es más fácil ya que siempre dividiremos la suma de la sucesión entre N. En cambio en el segundo caso tenemos que ver de esos N números cuántos se han imprimido al final para dividir la suma por ese número.

Para la solución a la primera situación sólo debemos contar que se ha impreso un elemento cuando este no sea múltiplo de X, y debemos de incrementar la variable que vamos imprimiendo siempre. El código quedaría algo así:

void sucesion(int multiplo, int repeticiones){
	int contador = 0, elemento = 1;
	float suma, promedio;
	while(contador < repeticiones){
		if(elemento % multiplo != 0){
			printf("%d  ", elemento);
			suma += elemento;
			contador++;
		}
		elemento++;
	}
	promedio = suma / repeticiones; // o (promedio = suma / contador) porque (contador == repeticiones)
	printf("\nEl promedio de la sucesion es: %.2f \n", promedio);
} 

Para la segunda solución debemos de contabilizar cada iteración, no sólo las que no sean múltiplo de X. Pero en este caso debemos llevar una cuenta aparte de cuántos dígitos hemos impreso para calcular el promedio. El código sería algo así:

void sucesion(int multiplo, int limite){
	int contador = 0;
	float suma, promedio;
	for(int elemento = 1; elemento <= limite; elemento++){
		if(elemento % multiplo != 0){
			printf("%d  ", elemento);
			suma += elemento;
			contador++;
		}
	}
	promedio = suma / contador; // (promedio = suma / limite) es incorrecto (contador < limite)
	printf("\nEl promedio de la sucesion es: %.2f \n", promedio);
} 

Y ahora un par de consejos para el futuro:
- Es recomendable usar nombres de variables que ayuden a comprender su utilidad. Nota la diferencia entre <repeticiones> código 1 y <limite> código 2.
- A no ser que sea tarea estudiantil y te obliguen a usar la llamada al sistema <system("pause")> hay alternativas mejores, para más información https://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html

Aparte para evitar la situación de que N < X podrías hacer uso de un filtro:

int repeticiones, multiplo;
	do{
		printf("Introduce el numero de valores para la sucesion: ");
		scanf("%d", &repeticiones);
		printf("Introduce el numero cuyos multiplos no deben aparecer en la sucesion: ");
		scanf("%d", &multiplo);
	}	while(repeticiones < multiplo); 

Exacto como bien te han explicado ahí no debes escribir:

perro1.~doggo(); 

Ya que el destructor de una clase se invoca automáticamente al terminar el programa. Además en los casos en que no usas memoria dinámica no es necesario definir el destructor ya que la clase proporciona uno por defecto (como ocurre con el constructor). En cambio si utilizas memoria dinámica, en el destructor tendrías que liberar esa memoria ya que sino el programa correrá aparentemente sin problemas pero estarás dejando memoria sin liberar.

¿Entonces si quieres aplicar el destructor explícitamente durante el programa? Muy sencillo, creas un método auxiliar con las instrucciones del destructor y en el destructor sólo llamas a ese método auxiliar. Así si quieres usarlo en otro punto del programa sólo deberás invocar al método auxiliar. Pero recuerda, si invocas el método auxiliar por ejemplo para liberar memoria dinámica, tendrás que volver a reservar memoria antes de llegar al final y de que se llame al destructor; sino estarás liberando dos veces la memoria y la segunda vez te producirá un error.

Doggo::miDestructor(){
    // instrucciones del destructor
}
 
Doggo::~Doggo(){
    miDestructor;
}
 
int main(){
    Doggo perro1;
    // otras instrucciones del programa
    perro1.miDestructor();
    // otras instrucciones del programa
    return 0;  // se llama automaticamente a ~Doggo()
} 

Aunque estás empezando ya llegarás a trabajar con memoria dinámica por lo que ten presente esto. Ánimo.

Sí, en el array <base1> me he confundido es un 3 como bien dices, no un 1. Por eso es bueno que revises mi explicación detalladamente porque al ser tan largas me puedo equivocar en algún sitio y no darme cuenta.

Para que veas como resolver este código te muestro un ejemplo con el comentario 3.
Imagina que tienes el número 18. 18 = 2 * 3 ^ 2 descompuesto en factores primos. Entonces supongamos que <aux1 = 18> (recuerda que <aux1> es tipo <float>):

for(i = 2; i <= aux1; i = i + 1){
	div1 = aux1 / i;
	div2 = aux1 / i; 

Empezamos con el 2 y dividimos <aux> (18 en nuestro caso) entre 2 y guardamos el resultado sin decimales en <div1>  porque es tipo <int> y el resultado con decimales en <div2> porque es tipo <float>. En nuestro caso <div1 = 9> y <div2 = 9.0>.

if (div1 - div2 == 0) 

Aquí comparamos que sean iguales, es decir que si el resultado sin decimales es igual al resultado con decimales significa que <aux> es divisible por <i>. En nuestro caso sí que lo es entonces analizamos el bloque del if.

aux1 = aux1 / i;
j = 1;
while (j <= 4) 

Con esto asignamos el valor de la división a aux1. En nuestro ejemplo <aux1 = 9> y empezamos a contar desde <j = 1> hasta <j = 4> incluido porque vamos a recorrer el array base1[5] que como su nombre indica almacena los números que dividen a <aux1>.

if (base1[j] == i){
    exp1[j] = exp1[j] + 1;
    j = 100;
} 

Para cada j en rango [1,4] comprobamos si ya hemos introducido antes ese divisor (recordemos <i = 2>). En el caso de que sí, se cumpliría el if y entonces aumentaríamos el exponente en esa posición. No es nuestro caso, pero si lo fuera se asignaría <j = 100> simplemente para que sea > 4 y así terminar el <while>.

if (base1[j] == 0){
    base1[j] = i;
    exp1[j] = 1;
    j = 100;
} 

En cambio si hay un 0 en el array base1 entonces metemos el divisor en esa posición y ponemos el exponente a 1. Se pone <j = 100> para salir del <while>.
Como es nuestro caso nuestros arrays quedarían así:
base1[5] = {0,2,0,0,0}
exp1[5] = {0,1,0,0,0}
Es decir que <aux1 = 18> es divisible por 2^1.

j = j + 1; 

Se reinicia el contador i a 1 ya que al terminar el <for> se ejecuta el incremento <i = i + 1> y entonces <i = 2>. ¿Por qué otra vez 2? Porque puede ser divisible por 2, más de 1 vez. Y se repite todo, ahora más rápido ya que te he explicado con detalle la primera iteración del <for>.

<i = 2> <aux1 = 9> -> 9 no es divisible por 2, entonces nos saltamos todo el <if> y hacemos otra iteración con <i = 3> (ahora no se ha hecho <i = 1> porque no hemos entrado en el <if>).
<i = 3> <aux1 = 9> -> 9 sí es divisible por 3, entonces <aux1 = 3> y entramos al if. ¿Existe ya el 3 en <base1>? No. Vamos al siguiente <if>, buscamos el primer 0 y metemos el 3 y ponemos a 1 el array <exp1> en esa posición. Resultado:
base1[5] = {0,2,1,0,0}
exp1[5] = {0,1,1,0,0}
Es decir que <aux1 = 18> es divisible por (2^1 * 3^1).

Ahora sí, reiniciamos i <i = 1> y otra iteración pero ahora <aux1 = 3>.
<i = 2> <aux1 = 3> -> 3 no es divisible por 2. No hacemos nada.
<i = 3> <aux1 = 3> -> 3 sí es divisible por 3, entonces <aux1 = 1> y entramos al <if>. ¿Existe ya el 3 en <base1>? Sí, entonces incrementamos el exponente y salimos del while. Resultado:
base1[5] = {0,2,3,0,0}
exp1[5] = {0,1,2,0,0}
Es decir que <aux1 = 18> es divisible por (2^1 * 3^2).

Ahora reiniciamos <i = 1> y <aux1 = 1>. Se ejecuta el incremento del <for> entonces <i = 2> y como no se cumple la condición del <for> ya que 2 > 1 entonces termina aquí este bloque.

Y ya tendríamos el número <aux1> descompuesto en factores primos, necesario para calcular el mcm y el mcd. Te recuerdo que aunque estoy escribiendo la posición 0 de los arrays en tus programas no se hace uso de ella (tus programas empiezan a contar en la posición 1).

Revisa la explicación, vete paso a paso comprendiendo lo que hace y porqué lo hace e intenta entender algún comentario más. La próxima duda que tengas espero que sea más específica ya que no puedo estar explicando un programa línea a línea. Por lo menos comenta hasta donde has entendido (o lo que te parezca que hace el programa) o que cosas entiendes para ahorrarme esas explicaciones.

Y recuerda que siempre puedes ir paso a paso como he hecho yo aquí poniendo cuanto vale cada variable en cada momento.

Es cierto, madre mía. Y yo que me había quedado buscando información a ver si encontraba algo sobre ese uso de los arrays y era todo por no haber usado la etiqueta para el código. No había caído en eso. Muchas gracias MAFUS, ahora ya sabré a que se debe esto.

Estudiante000000, para evitar más problemas de estos podrías meter todos tus códigos entre etiquetas de código. Si no sabes como se hace puedes:
- O bien cuando estás escribiendo un mensaje buscar encima un botón con el signo (< >) que pone "insertar código".
- O bien teclear tú mismo los [ ] donde pues escribir "code" para que aparezca la etiqueta de código o poner "code=<lenguaje>" para que resalte la sintaxis de ese lenguaje por ejemplo en tu caso ["code=C++"] <codigo> ["/code"] sin las comillas.

Si no estás seguro puedes probar a previsualizar el mensaje antes de publicarlo para que se vea todo bien.

En cuanto a la explicación del código, los primeros comentarios no deberías tener problemas para entenderlos, el primero es una simple inicialización y el segundo son filtros. El resto son bucles con operaciones aritmético-lógicas que para comprender su funcionamiento lo mejor es depurar paso a paso el programa para ir viendo lo que hace y si no sabes usar herramientas de depuración, entonces papel y boli.
Y si tienes dudas de una instrucción en concreto que no entiendas, entonces puedes dejar otro mensaje con tu duda, pero no con el ejercicio completo copiado tal cual sin muestras de haber dedicado mucho esfuerzo en comprenderlo.