C++ Exercício de vetores c++

Breno Baroni · 12 de junho de 2018

Segue o exercício:

#include <cstdio>
int main()
{
	int vet[8]={8,7,6,5,4,3,2,1}, i, j;
	for(i=0, j=7; i<=7; i++, j--) {
		vet[i] = i;
		printf("%d ", vet[j]);
	}
}

Eu não entendi o porque do resultado dar isso, nem fazendo debug eu entendi Alguem pode me explicar ?
R: 1, 2, 3, 4, 3, 2, 1, 0.

devair1010 · 12 de junho de 2018

@Breno Baroni é por que ele vai imprimindo do fim do vetor para o inicio enquanto ao mesmo tempo ele vai colocando o valor de i no começo do vetor , assim ele imprime até a metade do vetor normalmente , mas dai em diante como o j vai diminuindo ele passa a imprimir os valores de i que foram colocados no inicio do vetor .

Breno Baroni · 12 de junho de 2018

Nossa cara, muito obrigado. Eu tava com dor de cabeça aqui ja kkk obrigado mesmo

Simon Viegas · 12 de junho de 2018

Resumindo: o vetor está sendo invertido... mas ao mesmo tempo está sendo impresso da ordem inversa da inversão... ai a impressão sai misturada.. parte original, parte reordenada.

@Breno Baroni, qual o enunciado do problema?

Breno Baroni · 12 de junho de 2018

@Simon Viegas Era pra dizer o que iria ser imprimido na tela pelo programa.

Simon Viegas · 12 de junho de 2018

Entendi... tipo fazendo de cabeça, né?

	for(i=0, j=7; i<=7; i++, j--) {

Essa estrutura é um pouco estranha para mim... sou acostumado a ver o for com apenas 3 parâmetros.

Mas seria algo assim:

for (<primeira variável> com seu valor inicil,<segunda variável> com seu valor inicial; condição de parada; o que será feito ao final do loop; a segunda coisa que será feita ao final do loop)

Ai, mentalmente ou anotando num papel...:

Tendo:

		vet[i] = i;
		printf("%d ", vet[j]);

Primeiro loop

i=0; j=7;

Começa

{8,7,6,5,4,3,2,1}

Termina

{0,7,6,5,4,3,2,1}

Na tela

1

Segundo loop

i=1; j=6;

Começa

{0,7,6,5,4,3,2,1}

Termina

{0,1,6,5,4,3,2,1}

Na tela

1 2

Primeiro loop

i=2; j=5;

Começa

{0,7,6,5,4,3,2,1}

Termina

{0,1,2,5,4,3,2,1}

Na tela

1 2 3

Por ai

adicionado 6 minutos depois

Ou algo assim:

{8,7,6,5,4,3,2,1}

{0,7,6,5,4,3,2,1} | 1

{0,1,6,5,4,3,2,1} | 1 2

{0,1,2,5,4,3,2,1} | 1 2 3

{0,1,2,3,4,3,2,1} | 1 2 3 4

{0,1,2,3,4,3,2,1} | 1 2 3 4 3

{0,1,2,3,4,5,2,1} | 1 2 3 4 3 2

{0,1,2,3,4,5,6,1} | 1 2 3 4 3 2 1

{0,1,2,3,4,5,6,7} | 1 2 3 4 3 2 1 0

Breno Baroni · 12 de junho de 2018

@Simon Viegas fazendo com papel pelo "teste de mesa", o que eu tive dificuldade foi identificar que isso:

vet[i] = i;

estava colocando o resuldado na matriz :/ Preciso estudar mais kkk

Simon Viegas · 12 de junho de 2018

1 hora atrás, Breno Baroni disse:

estava colocando o resuldado na matriz :/ Preciso estudar mais kkk

Entendo que um dos segredos da programação é capacidade de abstrair (não sei se o termo é esse, mas seria mais ou menos isso). Apesar desse conceito está mais relacionado à Orientação a Objetos, ele na verdade está presente em tudo... vale também para C, como qualquer outra linguagem ou paradigma de programação... e inclusive para o dia-a-dia.

Outro segredo é que seria entender que o código ao ser executado tem duas características principais:

- e cada tarefa a ser executada interage com o estado das variáveis naquele momento. Ou seja, a cada "linha de execução" as variáveis podem estar um estado específico, ou seja, o que vale é aquele momento.

- de um modo geral, o computador vai executar uma tarefa de cada vez. Imagine um robô com apenas um braço. Essa característica tem relação com a anterior... o estado das memórias é alterada ou não em sequência unitárias...ou seja, as variáveis vão persistir o seu estado, até que algum comando as altere e essas alterações são feitas um a um. obs.: pode ser feitos alterações em lote, por exemplo, ao criar um vetor, e já definir os seus valores iniciais, como foi feito no seu código, seria como se um a um ele jogasse o 8 na posição 0, 7 na posição 1, 6 na posição 2... etc, mas esse "bloco" será executada de uma vez, antes da próxima instrução ser executada, ou seja, os estados das 8 variáveis antes era uma, e após todas serão outras...

Como assim:

Vamos pegar o seu código:

#include <cstdio> //aqui o compilador vai "incluir" tudo que
    //csdio tem no seu programa. Seria você copiar o código
    //dessa estrutura e colocasse dentro do seu. Desta forma,
    //os recurso dela ficam disponível no seu. Observe que
    //quanto mais "incluir", maior vai ficar o seu programa
int main() //aqui definiu que existirá um método de nome "main"
    //Cada método é como um subprograma, apenas que tem acesso
    //as coisas que estão no programa em si, ou seja, esse sub-
    //programa também vai enxergar o "cstdio", por exemplo
  
    //outra detalhe do "main" é que, ao "executar um código em C++",
    //o computador vai procurar o método que tem esse nome, ou seja,
    //é o método que é executado ao rodar o programa. Se não tiver
    //main, o programa não vai rodar...
    {
	int vet[8]={8,7,6,5,4,3,2,1}, i, j; //ao método ser instanciado, 
        //vai chegar nessa linha. O int no início vai significar que
        //quer criar variáveis desse tipo... o vet[8] que vão ser 8,
        //variáveis e que a referência a essa estrutura vai se chamar vet. 
        //a criação das variáveis tem uma estrutura específica, mas
        //podemos "abstrair"...
        //ai, cada uma das posições desse vetor, vão ter os respectivos
        //valores que estão nos {}, ou seja, o compilador entende essa estrutura
        //seria como se tivesse igualando um por um...
        //depois o computador vai criar a variável i e a j...
	for(i=0, j=7; i<=7; i++, j--) { //aqui, vai criar a estrutura de repetição
        //que terá mais ou menos aquelas características citadas na outra postagem.
        //Como funciona a estrutura para fazer que o computador repita? não sei, mas
        //sabemos como vair se comportar (abstraimos)
		vet[i] = i; //aqui, acho que funciona mais ou menos assim... começa pelo lado
        //direito. Pega o valor de i nesse exato momento, no primeiro loop está valendo 0,
        //então tem um 0 lá guardado. Após, acha o vet, vê que é um vetor, e posiciona
        //na posição 0, já que tem o [i], o [] servindo para posicionar e o i que vale 0
        //Daí, essa variável (que está na referência vet[0]) vai ter 0.       
		printf("%d ", vet[j]); //nesse momento, j vale 7, e vet na posição 7 tem o valor 1,
        //que foi definido lá quando criou a variável, logo, vai imprimir 1.
	} //ai o computador vai voltar lá para o início do for, e vai executar aqueles 2 últimos
    //parâmetros, ou seja, i vai ser =0+1 e j=7-1.
} //aqui encerra o programa

PS: vi agora... como o método foi definido para retornar um int, logo você tem que retornar um int, ficando algo como:

#include <cstdio>
int main()
{
	int vet[8]={8,7,6,5,4,3,2,1}, i, j;
	for(i=0, j=7; i<=7; i++, j--) {
		vet[i] = i;
		printf("%d ", vet[j]);
	}
	return 0; //aqui nessa linha, vai retonar no próprio método um valor, 
    //ou seja, a estrutura que invocou esse método main, se "colocasse para
    //imprimir o método", apareceria 0.
    //obs.: existe um motivo para retonar um int, algo como "verificar qual retorno
    //foi dado, ou seja, o 0 seria que "não deu erro algum", por exemplo. Ou poderia
    //ser para outra coisa... mais em fim, pode abstrair... o importante é que tem que
    //retonar algo, já que foi criado para retornar!, caso contrário, o método seria 
    //void. Algo como void main() {}
} //nessa caso, não vai chegar aqui, pois o return fecha o método

Por ai vai.

obs.: Pelo que eu vi, o C seria uma linguagem mais voltada para o paradigma de "Programação estruturada", "Programação imperativa" e "Programação procedural". Já o C++ seria "multiparadigmas". (vulgo "um bagulho mais louco"). Mas no momento, está programando como se fosse em C.

obs.2: Entretanto a sintaxe está para C++ mesmo, ou seja, o código não compila em C. (estava me referindo ao paradigma).