dontpanic

int indiceDado1 = d.nextInt(dado1.size()+1); Veja, desse modo você tá adicionando +1 a função size(), então em vez de ter nextInt(6) que retorna um número entre 0 e 5, agora você tem nextInt(7), que retorna um número entre 0 e 6.
Pra pegar um número entre 1 e 6, você precisa adicionar +1 ao resultado do nextInt():
int indiceDado1 = d.nextInt(dado1.size()) + 1;

A gente só pode ajudar se souber como você tá colocando isso em código.
Chutando, eu acho que é bem provável que você esteja abrindo os arquivos no modo escrita ("w") em vez do modo append ("a"). No modo escrita, o arquivo é sobrescrito toda vez que você abre ele. No modo append, você só adiciona.

Você tá usando variáveis locais nas funções que manipulam a pilha. Cada vez que essas funções terminam, a pilha é perdida.
Por exemplo, a função main chama a função inicializa(). Essa função adiciona um elemento naa pilha e inicializa ela, mas assim que essa função termina a pilha se perde. O main não tem como saber o que aconteceu naquela função. A mesma coisa acontece na função insere() e retira().

int x = 3452;
int setor = x / 1000; // 3
int func = x - (setor * 1000); // 452

Dei uma olhada no teu código.
Se o senhor permitir algumas observações:
1 - A primeira dela é sobre a função loading:

int main() { loading(); ...}int loading(void) { //Tela de carregamento printf("Carregando"); sleep(1); printf("."); sleep(1); printf("."); sleep(1); printf("."); sleep(1); printf(".");}Eu já vi funções desse tipo aqui no forum algumas vezes, e eu sempre fico intrigado quando vejo isso.Veja só, antigamente quando os computadores tinham tela verde, eles era bem lentos. Eles eram tão lentos que algumas coisas que hoje em dia são computadas instantaneamente, antigamente demoravam alguns segundos. E coisas que demoram alguns segundos hoje, antigamente demoravam minutos.
Pro usuário saber que o programa ainda estava funcionado, e que estava parado apenas pra computar algum dado e não porque tinha travado, alguns desenvolvedores começaram a usar barras de carregamento ou telas de espera.
O motivo dessas telas não era fazer o programa ficar parado por motivo nenhum, o motivo era apenas assegurar que o programa não tinha travado. Porque nenhum usuário nesse planeta deseja que seu programa seja lento de propósito. É por isso que a gente tá sempre comprando processadores mais rápidos.
2 - A segunda coisa é sobre modularização do código.
Modularização é quando você divide o seu programa em partes menores, pra ficar mais fácil de manter, expandir e corrigir os bugs que aparecem.
Por exemplo, se eu tiver um código onde todo processamento está na função main:

int main() { while( a+b > c) { if (x == y) { /* * um monte de codigo aqui */ } /* * mais codigo aqui */ for (i=0; i < 10; i++) { /* * mais codigo */ } } return 0;}Então se eu executar esse programa e tiver algum erro, eu vou ter que rever o código inteiro pra achar o bug.Mas se eu modularizar o programa:

void abrirArquivo() { /* * parte do codigo aqui */}int sortearVetor(int x) { /* * outra parte aqui */}int main() { while( a+b > c) { if (x == y) { abrirArquivo(); } for (i=0; i < 10; i++) { sortearVetor(i); } } return 0;}Daí em caso de erro fica mais fácil de isolar o problema.O exemplo acima foi bem simples, mas você pode ir adiante. Em vez de separar não só em funções, você pode usar arquivos diferentes também.
Pode colocar a parte de manipular arquivos em "arquivo.c" e "arquivo.h" e no programa principal, o "main.c", você usa um "#include "arquivo.h".
Essa coisa de modularização é especialmente importante se você pretende que outras pessoas colaborem no seu código.
Cada pessoa trabalha em um arquivo.
3 - E a terceira observação é quanto a organização do código.
Principalmente se você pretende que outras pessoas colaborem com o seu código, é muito importante que ele seja legível pra todo mundo que vai ler o código.
Isso pode parecer besteira, mas eu garanto que é mais importante do que parece.
Por exemplo, colocar comentários no código é muito importante, mas colocar comentários em excesso acaba deixando o código ruim de ler, principalmente quando são 3 da manhã e você tá com os olhos cansados.

scanf("%d", &command); //Cria um entrada para comandoQualquer pessoa que começou a aprender C ontem sabe o que o scanf faz, então aquele comentário é desnecessário.Ou código sem indentação correta.
É isso.
Espero que considere isso como críticas construtivas.
Se precisar de ajuda em algo fique a vontade pra postar.

Esses símbolos, '%d', '%c', '%lf' são máscaras ou marcadores que vão dizer a função fscanf que tipo de dado capturar do buffer.
 
Pense no seu arquivo como uma sequencia de dados:
"835139        1998           1           1  0.300000012" ---> <numero inteiro> <espaço> <numero inteiro> <espaço> <numero inteiro> <espaço> <numero inteiro> <espaço> <numero fracionário>
 
Então esses símbolos vão dizer ao fscanf o que esperar do stream.
%d equivale a um numero inteiro (int)
 
Então o comando: fscanf(arquivo, "%d", &x)
Vai abrir o buffer do arquivo, vai capturar o primeiro dado na sequencia, interpretar ele como um número inteiro e guardar seu valor na variável 'x'.
O valor de 'x' após o comando vai ser '835139'.
 
Se você tivesse um arquivo com apenas uma linha contendo:
"azul 123 a"
E você quisesse ler o conteúdo dele com a função fscanf, você usaria esse comando:
fscanf (arquivo, "%s %d %c", string, &numero, &letra);
 
O %s equivale a uma string --> "azul"
O %d equivale a um número --> 123
E o %c equivale a uma única letra --> 'a'
 
A função fscanf recebe como argumentos os endereços das variáveis onde ela vai guardar os dados que capturou, por isso você precisa usar o & antes dos nomes das variáveis.
 
Em C++ a lógica é parecida, mas o código é diferente:
Em vez de usar uma variável do tipo FILE e a função fopen() pra abrir seu arquivo, você declara um objeto do tipo fstream e chama o método open do próprio objeto.
Em vez de usar a função fscanf() pra ler dados do arquivo e fprintf pra escrever dados no arquivo, você simplesmente usa os operadores '>>' e '<<' pra entrada e saída do stream.
 
Exemplo:
#include <iostream>#include <fstream>#include <string>using namespace std;int main () {    string s;    int i;    char c;     ifstream arquivo;    arquivo.open ("teste.txt"); // abriu o arquivo 'teste.txt' pra leitura    arquivo >> s >> i >> c; // isso é o equivalente a fscanf(arquivo, "%s %d %c", s, &i, &c);    arquivo.close();     cout << s << i << c << endl;    return 0;}

Bem... você tem que considerar o fluxo do programa.
for(k=0; k <2; k++){    printf("Informe: ");    scanf("%s", nome);}for(k=0; k <2; k++){    printf("\nNome: %s", nome);}  
Pro compilador, o programa acima é o equivalente a isso:
int k;k = 0;if (k < 2) {    printf("Informe: ");    scanf("%s", nome);}k++; // k --> 1 if (k < 2) {    printf("Informe: ");    scanf("%s", nome);}k++; // k --> 2 k = 0;if (k < 2)    printf("\nNome: %s", nome);k++; if (k < 2)    printf("\nNome: %s", nome);k++;  
Como pode ver, a ordem do programa torna impossível você imprimir dois nomes diferentes usando a mesma variável.
Quando você coloca o segundo nome em 'nome', o primeiro nome que você digitou se perde, pois o segundo é escrito por cima dele.
 
É a mesma coisa de ter:
int x;
x = 1;
x = 2; // o valor '1' se perdeu pra sempre pois '2' foi escrito na posição da memória dele
 
Você precisa guardar ele em algum lugar se quiser usar o valor dele adiante no código.
 
#include <stdio.h>int main() {    int k;    char nome[2][30];    for (k=0; k < 2; k++) {        printf("Informe: ");        scanf("%s", nome[k]);    }    for(k=0; k <2; k++) {        printf("\nNome: %s", nome[k]);    }     return 0;}

Um bug que eu achei: scanf("%s", &pergunta); --> pergunta é um int, mas você tá passando ele pro scanf como string
 
Quanto ao motivo do erro, é o seguinte:
Quando a função main chama a função imprimeMenu(), você escolhe uma opção e o scanf guarda o valor em 'op', certo?
 
scanf("%d", &op);
 
Imagine o buffer do stdin como uma mangueira. De um lado fica entrando água (a torneira, ou seja, o teclado alimentando as teclas) e do outro fica vazando água (a saída, ou seja, o scanf/fgets/etc).
 
Digamos que você digite '1' e depois aperte ENTER pra confirmar ('\n').
Então a mangueira do buffer fica aqui:
 
saída --> [1] ['\n'] [ ] [ ] [ ] [ ] ... <-- entrada
 
O buffer captura tanto o número que você digitou quanto o ENTER.
E o scanf tava esperando um número (%d) então ele vai no buffer e retira o número de lá e guarda em 'op'.
Mas aquele enter que você digitou ainda fica no buffer:
 
['\n'] [ ] [ ] [ ] [ ] ...
 
Daí agora você saiu da função imprimeMenu, o main chama a função cabecalho() e essa função usa o scanf novamente:
 
scanf("%d", &op2);
 
Dessa vez em vez de esperar você digitar algo, a função vai checar o buffer do stdin e vai ver que ainda tem um valor lá (o enter que sobrou) e já vai pegar esse valor ('\n') e colocar em 'op2', achando que foi um número que você digitou. Normalmente quando você tem um monte de printf() depois de um scanf(), o buffer acaba sendo limpo automaticamente, pois tanto o printf quanto o scanf usam o mesmo buffer. Mas quando você usa dois ou mais scanf()'s próximos um do outro (que é o caso entre a função cabecalho() e cadastro()) daí o lixo de um acaba passando pro outro.
 
Pra resolver isso você tem algumas opções:
- Usar o fflush(stdin):
Essa função supostamente esvazia o buffer. Então bastaria você usar ela nas funções imprimeMenu() e cabecalho() depois dos scanf() pra garantir que as próximas funções vão receber o buffer vazio). O único problema do fflush() é que ela não é muito segura... por exemplo, no linux nem sempre ela faz o que se propõe, e alguns compiladores implementam ela de jeito diferente. Então teste antes pra ver se tá limpando o buffer mesmo.
 
- Manipular o scanf() pra ele já ignorar o ENTER depois de pegar um número ou character:
Essa é meio gambiarra, mas você pode usar por exemplo:
scanf("%d", &op); --> captura um numero do buffer e guarda em op
scanf("%*c"); --> captura e descarta um char do buffer (o enter que sobrou)
 
- Criar uma função só pra pegar números, usando o getchar(), assim como eu fiz lá com a função de capturar nomes. Daí você tem mais controle sobre o buffer.

Você incluiu o header nos includes, agora falta adicionar a biblioteca no linker.
Provavelmente existe um arquivo chamado "libmysql.lib" ou algo parecido na pasta onde você instalou o mysql, e você precisa adicionar ele ao seu projeto.
Se houver alguma dll do mysql, ela precisa também estar na sua pasta de sistema, ou na pasta do seu executável.

Mas esse não é o valor de PI... se você der uma olhada na questão de novo, vai ver que esse somatório apenas faz uma aproximação pra PI^2 / 6, que é mais ou menos 1.64.
Quando você roda aquela função com uma parcela, ela retorna 1... com duas 1.25... com três 1.36... quanto mais parcelas, mais o valor se aproxima de 1.64.
 
Além disso, tem um erro aqui:
for (int i=1;i<n;i++) ---> for (int i=1;i<=n;i++)

1.
'cin >>' é uma função, como outra qualquer no c++. O motivo pelo qual você tá acessando ela com o operador '>>' é porque a classe a qual o cin pertence (istream) faz overload desse operador. Mas no overload ele recebe apenas um parametro por vez.
Então fazer 'cin >> x, y, z' é incorreto pois foge da sintaxe dele. Ele só consegue capturar o primeiro parametro.
Se quiser pode usar 'cin >> x >> y >> z'.
2.
Acho que tá correto... não percebi nada errado.
3.
Nessa parte do código:
for (int i=0;i<6;i++){
troca(vet[5-i],vet);
}
Você tá trocando o elemento 5 por 0... o 4 por 1... o 3 por 2.
Até aí tudo bem... mas como o FOR vai de 0 até 5, então você acaba trocando também o 2 por 3... 1 por 4 e 0 por 5.
Ou seja, até a metade do FOR você trocou os elementos, mas na outra metade do FOR você trocou eles de volta pros valores originais.
Basta fazer o FOR de 0 até 6/2.

Bom dia.
Então...  uma função só pode retornar um único valor em C/C++. Se você precisar receber/alterar mais de um valor você tem algumas opções:
 
Alterar os valores por referência:

void sexo(int *vetor, int tam, int &maior, int &menor) {    maior = vetor[0];    menor = vetor[0];    for (int i=1; i < b; i++) {        if (a[i] > maior) {            maior = a[i];        }        if (a[i] < menor) {            menor = a[i];        }    }} int main() {    int maior;    int menor;    int vet[10];    ...    sexo(vet, 10, maior, menor);    cout << "O maior numero digitado foi: " << maior << " e o menor numero digitado foi: " << menor << endl;     return 0;} Como 'maior' e 'menor' foram passados por referência pra função 'sexo()', então as mudanças que você fizer neles dentro da função serão refletidas no main também.
 
Criando uma struct:

struct resultados {    int maior;    int menor;}; resultados sexo(int *vetor, int tam) {    resultados res;    res.maior = vetor[0];    res.menor = vetor[0];    for (int i=1; i < b; i++) {        if (a[i] > res.maior) {            res.maior = a[i];        }        if (a[i] < res.menor) {            res.menor = a[i];        }    }    return res;} int main() {    resultados res;    int vet[10];    ...    res = sexo(vet, 10);    cout << "O maior numero digitado foi: " << res.maior << " e o menor numero digitado foi: " << res.menor << endl;     return 0;} Usando um std::pair:

pair<int,int> sexo(int *vetor, int tam) {    int maior = vetor[0];    int menor = vetor[0];    for (int i=1; i < b; i++) {        if (a[i] > maior) {            maior = a[i];        }        if (a[i] < menor) {            menor = a[i];        }    }    return make_pair(maior, menor);} int main() {    pair<int,int> res;    int vet[10];    ...    res = sexo(vet, 10);    cout << "O maior numero digitado foi: " << res.first << " e o menor numero digitado foi: " << res.second << endl;     return 0;}

É que você precisa inicializar os valores de C antes de usar o "+=".
É só colocar isso no teu código antes de acessar C:

for (int i=0;i<3;i++) for (int j=0;j<3;j++) C[i][j] = 0;

É só colocar as expressões que você quer que sejam resolvidas antes do println entre parenteses.

System.out.println("Resultado da soma é: "  + (x=5+4) );

p é o número de pares... e já que você só vai ler 5 números então "(5 - p)" é o número de ímpares.

cout << "voce digitou " << p << " numeros pares e " << 5-p << " numeros impares" << endl;

Um int guarda inteiros, certos? 1, 2, 3, 4, etc...
Um float guarda números reais. 0.239, 1.5, 3.14, etc...
Um ponteiro guarda endereços da memória.
 
Por exemplo:

int main() {    int x; int y;    return 0;} Nesse código acima, quando esse programa for executado ele vai pedir ao sistema operacional pra reservar uma parte da memória RAM pra variável x e y.
 
Sua memória ram:

[foto de mulher pelada] [0] [0] [0] [0] [email] [0] [0] [0][0] [0] [0] [0] [x] [0] [0] [firefox ] [0] [0] [0] [y] [0][0] [0] [0] ...Como tem sempre alguma coisa acontecendo no seu sistema operacional e na memória ram, ela precisa ser subdividida em endereços, pros programas serem capazes de acessar as informações gravadas lá.Digamos que no exemplo acima, "foto de mulher pelada" esteja no endereço 0x00 (zero), "email" esteja no endereço 0x0E, "x" esteja no endereço 0x18 e "y" no endereço 0x20.
Daí você muda seu programa agora:

int main() { int x; int y; int *px; int *py; px = &x; py = &y; return 0;}Esse operador "&" significa que em vez de pegar o valor de uma variável, eu estou pegando o endereço dela na memória.Então "px" vai ser igual a 0x18, que é o endereço de x... E "py" vai ser igual a 0x20, que é o endereço de y.
O que o exercício pede é que você crie uma função inverta os endereços dessas duas variáveis, de modo que px fique igual a 0x20 e py igual a 0x18.
 

#include <iostream>using namespace std;void swap(int* &a, int* & { int* t; t = a; a = b; b = t;}int main() { int x = 10; int y = 20; int* px = &x; // px guardando o endereço de x, *px = 10 int* py = &y; // py guardando o endereço de y, *py = 20 cout << "px: " << *px << endl; cout << "py: " << *py << endl; swap( px, py ); cout << "px: " << *px << endl; cout << "py: " << *py << endl; return 0;}

"soma" e "b" são inteiros... a divisão de dois números inteiros sempre vai resultar em um número inteiro, no c++.
Pra pegar o resultado fracionado, primeiro você muda o tipo da função "media()" pra float, depois você faz o cast de soma pra float.
 
media = (float) soma / (b-1);

Quando tiver uma dúvida assim, basta fazer o famoso "teste de mesa", ou "escreva no papel os valores da memória".
 
for(i=0;nome;i++);
 
Esse código acima, vai apenas pegar o tamanho de nome[] e colocar em i.
Cada string que você digita com o scanf ou gets termina em um character nulo ("\0"), então esse FOR vai testar se nome é igual a zero, quando sim, o FOR termina e i terá o tamanho da string.
(Era mais simples usar strlen() )
 
for(j=0;nome2[j];j++)
 
No segundo FOR, digamos que i seja igual a 20, que é o tamanho de nome, e j começará em 0. Então, no primeiro loop desse for você terá:
nome2[0] = nome[20 -0 -1] ---> nome2[0] será igual a nome[19]
 
Segundo loop, j é igual a 1:
nome2[1] = nome[20 -1 -1] ---> nome2[1] será igual a nome[18]
 
Terceiro loop, j igual a 2:
nome2[2] = nome[20 -2 -1] ---> nome2[2] = nome[17]
 
E assim por diante.
Ele tá percorrendo o array nome2[] de 0 até 20, e colocando nele os elementos do array nome[] de 20 até 0.
 
A única coisa que tô achando estranho é o critério de parada da segunda array (nome2[j]), pois testei aqui e não funciona. Ou você digitou errado, ou tem alguma parte do código antes disso que inicializou aqueles valores.

Com o fgets você não usa máscaras... qualquer processamento é feito depois, na string capturada por ele.
Por exemplo, se o seu fgets pegou a string "FN:Bruno Eduardo" então basta copiar os caracteres string[3] até string[15] pra uma substring.
 
Você pode copiar manualmente (faz um FOR copiando os characters) ou então usa a função memcpy() ou strncpy().
Ex:
#include <stdio.h> #include <string.h> int main() { char string1[20] = { "Ola mundo\0" }; char string2[10]; memcpy( string2, string1+4, 6 ); printf("%s\n", string2); return 0; } Edit:
Sobre o "%*4c", o asterisco tá dizendo pra ignorar o que vier a seguir. O 4c significa "4 caracteres".
Então "%*4c%s" --> Ignore os 4 caracteres a seguir e guarde o restante numa string.
O site que eu uso pra pegar essas referências é http://www.cplusplus.com/reference/cstdio/scanf/
Mas eles não explicam muito bem lá... pra ser sincero são poucos livros/sites que explicam esse tipo de coisa. O jeito é sair testando mesmo.

Você tá usando o mesmo nome de variável pro scanner e pra string.
Variáveis precisam ser únicas.

O último da série (o 99) é:
F(99) = 218.922.995.834.555.169.026
 
E pra representar ele você vai precisar de mais de 8 bytes.
Dependendo do compilador que você esteja usando, do sistema operacional (32bits, 64bits), etc, é bem provável que o valor máximo que você consiga representar usando apenas o C puro e as bibliotecas padrão, seja 8 bytes usando um "unsigned long long int".
 
Eu testei aqui e consegui ir até F(93):
 

#include <stdio.h>#include <stdlib.h> int main() {     int i;    unsigned long long int f1 = 0;    unsigned long long int f2 = 1;    unsigned long long int f3;     printf("%llu\n",f1);    printf("%llu\n",f2);     for( i=2; i<100; i++) {        f3 = f1 + f2;         printf("%d - %llu\n",i,f3);        f1 = f2;        f2 = f3;    }    printf("\n");     return 0;} Depois do 93, nem mesmo os 8 bytes do longlongint dão conta... daí pra representar valores maiores que esse você vai precisar usar alguma biblioteca própria pra isso.
Eu sei que no visual studio existe alguns tipos que são capazes se representar valores maiores. Mas como você tá usando o gcc, recomendo dar uma olhada numa biblioteca chamada inttypes.h.

Eu tô meio perdido aqui. Pelo que entendi, você quer o seguinte;
 
AB: [01] [11]
BC: [01] [11]
CD: [01] [11]
 
Você quer testar o primeiro par de AB tanto com o primeiro par de BC quanto o segundo, depois testar isso tudo tanto com o primeiro par de CD quanto o segundo... é isso?
 
assign(AB, 'AB.txt');reset(AB);WHILE NOT EOF(AB) DOBEGIN        READLN(AB, X);        X1:=ord(X[1])-Ord('0');        X2:=ord(X[2])-Ord('0');         assign(BC, 'BC.txt');        reset(BC);        WHILE NOT EOF(BC) DO        BEGIN                READLN(BC, Y);                Y1:=ord(Y[1])-Ord('0');                Y2:=ord(Y[2])-Ord('0');                 assign(CD, 'CD.txt');                reset(CD);                WHILE NOT EOF(CD) DO                BEGIN                        READLN(CD, Z);                        Z1:=ord(Z[1])-Ord('0');                        Z2:=ord(Z[2])-Ord('0');                         IF (X2=Y1) AND (Y2=Z1) THEN                                writeln( ... );                 END;                 close(CD);        END;        close(BC);END;close(AB);  
Não testei o código acima. Mas acho que é isso.
Não sei se é necessário abrir e fechar os arquivos em todo while... talvez se apenas usar o reset() já funcione.

Tem dois erros aí... o primeiro é que você não precisa usar o "std::", porque lá em cima no código você já tá usando o namespace std.
 
O segundo é que você precisa pensar no objeto string como se fosse um tipo (assim como int, float, char, etc).
Então cada vez que você coloca no teu código "string u = ..." é como se você tivesse declarando a variável u novamente, o que é errado.
 
Só precisa declarar ela uma vez, no começo do código, assim como qualquer outra variável, e aí no resto do código você faz as atribuições.
 
#include <iostream>#include <string>using namespace std;int main(){    int a,b,c;    string u;    cout<<"digite as bagaças ae: ";    cin>>a,b,c;    if (a>=b & b>=c){        if (a==b & b==c){           u = "CHARUTO";            }            else if (a!=b & b!=c){            u = "ESCALENO";            }    ...    return 0;}  
Além disso, por que você tá usando a <string.h> e <stdlib.h> se o seu código é em c++?

Sua matriz é 3x3, certo? Então você acessa os membros de 0,0 até 2,2.
 
matriz90[j][4-i]=matriz[j];
 
Quando i for igual a 0, e j for igual a 0, você estará acessando a posição 0,4... que é inválida.
Quando i for igual a 1, você estará acessando a posição j,3... que também é inválida.

Pelo que eu entendi do enunciado, você precisa primeiro preencher o vetorA apenas com elementos pares, depois o vetorB apenas com elementos ímpares, e depois colocar tudo no vetorC.
 
Mas você tá preenchendo um vetor temporário, depois pegando os valores desse vetor temporário e colocando nos vetores A e B.
 
Ou seja, se o usuário digitar apenas valores pares, o vetor B vai ficar vazio.
Outro problema é que você tá passando o valor NULL pro seu vetor de ints. Mas NULL não é do tipo int.
 
O seu programa deveria ser assim:
 
#include <stdio.h>#include <stdlib.h> int main() {    int vetorA[6];    int vetorB[6];    int vetorC[12];    int x;     // Pede pro usuário preencher o vetorA aqui    { ... }     // Pede pro usuário preencher o vetorB aqui    { ... }     // Com os elementos de vetorA e vetorB você preenche os elementos do vetorC aqui    { ... }     // Imprime os elementos de vetorC    for (x = 0; x < 12; x++)        printf("%d ", vetorC[x]);     printf("\n");     return 0;}  
Pra preencher os vetores com os dados que o usuário digitar, e ao mesmo tempo testar se eles são pares ou ímpares, você pode usar um DO/WHILE:
 
x = 0;do {    printf ("Digite um valor pro vetorA");    scanf("%d", &vetorA[x]);    if (vetorA[x] % 2 == 0)        x++;} while (x < 6);  
No código acima, quando o usuário digitar um valor pro vetorA, o programa testa se aquele valor é PAR, caso ele seja, então passa pro próximo elemento do vetorA (com x++). Se não for par, então o DO/WHILE repete a mesma posição do vetor.
 
Pra preencher os valores do vetorC, você pode usar a regra que quiser. O enunciado não diz como você deve fazer a junção. Então você pode por exemplo, colocar os elementos do vetorA nas posições 0 até 5 do vetorC, e os elementos do vetorB nas posições 6 até 11.
 
Exemplo:
for (x = 0; x < 6; x++) {    vetorC[x] = vetorA[x];    vetorC[x+6] = vetorB[x];}  
É isso.