AULA 15 - Microcontroladores - Técnico - Histórico de revisão

imported>Fargoud: /* PONTEIROS PARA MATRIZES USANDO FUNÇÕES */

2019-10-31T11:10:31Z

PONTEIROS PARA MATRIZES USANDO FUNÇÕES

← Edição anterior		Edição das 08h10min de 31 de outubro de 2019
Linha 500:		Linha 500:
	Exemplos		Exemplos

	/******************************************************************************/		/******************************************************************************/
	/*** Programa que procura um caractere em uma "string" ~~****~~****/		/*** Programa que procura um caractere em uma "string" ****/
	/******************************************************************************/		/******************************************************************************/
	#include <stdio.h>		#include <stdio.h>
	#include <conio.h>		#include <conio.h>

	char procstr(char , char);		char procstr(char , char);

	void main(void)		void main(void)
	{		{
	char *ptr;		char *ptr;
	char ch, lin[81];		char ch, lin[81];
Linha 525:		Linha 525:
	else printf("\n caractere nao existe. \n");		else printf("\n caractere nao existe. \n");
	getche();		getche();
	}		}

	char procstr(char linha,char c)		char procstr(char linha,char c)
	{ while(linha != c && linha != '\0')		{ while(linha != c && linha != '\0')
	linha++;		linha++;
	if(*linha != '\0')		if(*linha != '\0')
	return(linha+ 1);		return(linha+ 1);
	else		else
	return(0);		return(0);
	}		}

imported>Fargoud: /* PONTEIROS */

2019-10-24T13:16:13Z

PONTEIROS

← Edição anterior		Edição das 10h16min de 24 de outubro de 2019
Linha 1:		Linha 1:
	=PONTEIROS=		=PONTEIROS=

	Uma das características ~~mas~~ poderosas oferecidas pela linguagem C é o uso de ponteiros.		Uma das características mais poderosas oferecidas pela linguagem C é o uso de ponteiros.

	Mas também é visto como um do tópicos mais complexos da linguagem.		Mas também é visto como um do tópicos mais complexos da linguagem.

imported>Fargoud: /* PONTEIROS PARA MATRIZES USANDO FUNÇÕES */

2017-06-08T18:29:45Z

PONTEIROS PARA MATRIZES USANDO FUNÇÕES

← Edição anterior		Edição das 15h29min de 8 de junho de 2017
Linha 462:		Linha 462:
	Como exemplo, vamos ver a função adcon1(), que adiciona uma constante a todos os elementos de uma matriz.		Como exemplo, vamos ver a função adcon1(), que adiciona uma constante a todos os elementos de uma matriz.

	#include <stdio.h>		#include <stdio.h>
	#define TAM 5		#define TAM 5

	void adcon1(int *, int, int);		void adcon1(int *, int, int);

	void main(void)		void main(void)

imported>Fargoud: /* Exercícios */

2017-06-08T17:52:40Z

Exercícios

← Edição anterior		Edição das 14h52min de 8 de junho de 2017
Linha 396:		Linha 396:
	==Exercícios==		==Exercícios==
	#"Os ponteiros permitem a passagem de valores por referência para uma função". Demonstre esta propriedade através de um programa.		#"Os ponteiros permitem a passagem de valores por referência para uma função". Demonstre esta propriedade através de um programa.
	# Faça um programa que calcule a média aritmética de um número arbitrário de notas de		# Faça um programa que calcule a média aritmética de um número arbitrário de notas de provas, usando matrizes.
	#Repita o programa acima, agora utilizando ponteiros.		#Repita o programa acima, agora utilizando ponteiros.

imported>Fargoud: /* Exercícios */

2017-06-08T17:51:57Z

Exercícios

← Edição anterior		Edição das 14h51min de 8 de junho de 2017
Linha 395:		Linha 395:

	==Exercícios==		==Exercícios==
	#"Os ponteiros permitem a passagem de valores por referência para uma função". Demonstre		#"Os ponteiros permitem a passagem de valores por referência para uma função". Demonstre esta propriedade através de um programa.
	esta propriedade através de um programa.
	# Faça um programa que calcule a média aritmética de um número arbitrário de notas de		# Faça um programa que calcule a média aritmética de um número arbitrário de notas de
	#Repita o programa acima, agora utilizando ponteiros.		#Repita o programa acima, agora utilizando ponteiros.

	Exemplos		Exemplos
	/~~******************~~********************************************************/		/**********************************************************/
	/*** Programa que procura um caractere em uma "string" ~~********~~/		/*** Programa que procura um caractere em uma "string" /
	/~~******************~~********************************************************/		/**********************************************************/
	#include <stdio.h>		#include <stdio.h>
	#include <conio.h>		#include <conio.h>
	char procstr(char , char);		char procstr(char , char);
	void main(void)		void main(void)
	{		{
	char *ptr;		char *ptr;
	char ch, lin[81];		char ch, lin[81];
	puts("Digite uma frase: ");		puts("Digite uma frase: ");
	gets(lin);		gets(lin);
	printf("Digite o caractere a ser procurado: ");		printf("Digite o caractere a ser procurado: ");
	ch = getche();		ch = getche();
	ptr = procstr(lin, ch);		ptr = procstr(lin, ch);
	printf("\n A string comeca no endereço %u.\n",lin);		printf("\n A string comeca no endereço %u.\n",lin);
	if(ptr)		if(ptr)
	{ printf("Primeira ocorrencia do caractere: %u.\n", ptr);		{ printf("Primeira ocorrencia do caractere: %u.\n", ptr);
	printf("E a posição: %d", ptr-lin);		printf("E a posição: %d", ptr-lin);
			}
			else printf("\n caractere nao existe. \n");
			getche();
	}		}
	~~else printf("\n caractere nao existe. \n");~~
	~~getche();~~		char procstr(char linha,char c)
	}		{ while(linha != c && linha != '\0')
	char procstr(char linha,char c)		linha++;
	{ while(linha != c && linha != '\0')		if(*linha != '\0')
	linha++;		return(linha+ 1);
	if(*linha != '\0')		else
	return(linha+ 1);		return(0);
	else		}
	return(0);
	}

	=ARITMÉTICA DE PONTEIROS=		=ARITMÉTICA DE PONTEIROS=

imported>Fargoud: /* PONTEIROS E MATRIZES */

2017-06-08T17:50:16Z

PONTEIROS E MATRIZES

Mostrar alterações

imported>Fargoud em 17h43min de 8 de junho de 2017

2017-06-08T17:43:25Z

Mostrar alterações

imported>Fargoud: /* PONTEIROS E MATRIZES */

2017-06-08T17:41:09Z

PONTEIROS E MATRIZES

Mostrar alterações

imported>Fargoud: /* PONTEIROS E MATRIZES */

2017-06-08T17:13:21Z

PONTEIROS E MATRIZES

← Edição anterior		Edição das 14h13min de 8 de junho de 2017
Linha 86:		Linha 86:

	Existe uma correspondência muito grande entre ponteiros e matrizes.		Existe uma correspondência muito grande entre ponteiros e matrizes.
	O nome de uma matriz é equivalente ao endereço do primeiro elemento na matriz. Como isto é imutável, podemos chamar o nome de uma matriz de "ponteiro constante". Já um ponteiro comum tem conteúdo variável, pode conter qualquer endereço, sendo porisso chamado de "ponteiro variável". Pode-se fazer, portanto:
			O nome de uma matriz é equivalente ao endereço do primeiro elemento na matriz.

			Como isto é imutável, podemos chamar o nome de uma matriz de "ponteiro constante".

			Já um ponteiro comum tem conteúdo variável, pode conter qualquer endereço, sendo porisso chamado de "ponteiro variável".

			Pode-se fazer, portanto:

	int imat[5] = {5,7,31,18,22};		int imat[5] = {5,7,31,18,22};
	int *ip;		int *ip;
	...		...
	ip = imat; // OU ip=&imat[0];		ip = imat; // OU ip=&imat[0];

			e teríamos, por exemplo, "*(ip+n)" como sendo o valor do n-ésimo elemento da matriz imat.


	~~e teríamos, por exemplo, "(ip+n)" como sendo o valor do n-ésimo elemento da matriz imat.~~ Isto porque o significado da adição ou subtração de um inteiro com um ponteiro é adicionar ou subtrair o tamanho de memória do tipo da variável (sizeof) para o qual o ponteiro foi declarado. ~~Em outras palavras, ip não vai ser incrementado de n bytes de memória, mas de 2 bytes n, pois o tipo int ocupa 2 bytes. A disposição na memória, por exemplo, seria:~~		Isto porque o significado da adição ou subtração de um inteiro com um ponteiro é adicionar ou subtrair o tamanho de memória do tipo da variável (sizeof) para o qual o ponteiro foi declarado.

	Variável Endereço Valor		Em outras palavras, ip não vai ser incrementado de n bytes de memória, mas de 2 bytes * n, pois o tipo int ocupa 2 bytes. A disposição na memória, por exemplo, seria:

			Variável Endereço Valor
	imat 567 630		imat 567 630
	imat[0] 630 5		imat[0] 630 5
Linha 101:		Linha 114:
	imat[3] 636 18		imat[3] 636 18
	imat[4] 638 22		imat[4] 638 22
	ip 802 630		ip 802 630

	então:		então:
	Expressão Valor Explicação
	ip 630 endereço de imat[0]		Expressão Valor Explicação
	*ip 5 valor em 630		ip 630 endereço de imat[0]
	ip + 1 632 endereço de imat[1]		*ip 5 valor em 630
	*(ip+1) 7 valor em 632		ip + 1 632 endereço de imat[1]
	*ip + 1 6 valor em 630 mais 1		*(ip+1) 7 valor em 632
			*ip + 1 6 valor em 630 mais 1
	imat[0] 5		imat[0] 5
	*(imat) 5		*(imat) 5
	imat[1] 7		imat[1] 7
	*(imat+1) 7		*(imat+1) 7

	Com strings é a mesma coisa:		Com strings é a mesma coisa:
Linha 118:		Linha 133:
	char *pc="ABC";		char *pc="ABC";

	define um ponteiro para a série de caracteres "ABC" (terminada com "\0"). O ponteiro pc tem portanto, como valor, o endereço do primeiro elemento da série, o caractere 'A'.		define um ponteiro para a série de caracteres "ABC" (terminada com "\0").


			O ponteiro pc tem portanto, como valor, o endereço do primeiro elemento da série, o caractere 'A'.

	Pode-se ter, também, matrizes de ponteiros:		Pode-se ter, também, matrizes de ponteiros:

Linha 124:		Linha 143:

	por exemplo, declara cp como sendo uma matriz de 3 ponteiros para caracteres e já inicializa-os, fazendo-os apontar para as três sequências de caracteres.		por exemplo, declara cp como sendo uma matriz de 3 ponteiros para caracteres e já inicializa-os, fazendo-os apontar para as três sequências de caracteres.

	Na memória isto ficaria:		Na memória isto ficaria:



	Variável Endereço Valor		Variável Endereço Valor
	constante 731 'X'		constante 731 'X'
	constante 732 'Y'		constante 732 'Y'
	constante 733 'Z'		constante 733 'Z'
	constante 734 '\0'		constante 734 '\0'
	constante 735 'Q'		constante 735 'Q'
	constante 736 'R'		constante 736 'R'
	constante 737 'S'		constante 737 'S'
	constante 738 '\0'		constante 738 '\0'
	constante 739 'K'		constante 739 'K'
	constante 740 'L'		constante 740 'L'
	constante 741 'M'		constante 741 'M'
	constante 742 '\0'		constante 742 '\0'
	cp[0] 900 731		cp[0] 900 731
	cp[1] 902 735		cp[1] 902 735
	cp[2] 904 739		cp[2] 904 739


	=ARITMÉTICA DE PONTEIROS=		=ARITMÉTICA DE PONTEIROS=

imported>Fargoud em 17h11min de 8 de junho de 2017

2017-06-08T17:11:23Z

← Edição anterior		Edição das 14h11min de 8 de junho de 2017
Linha 1:		Linha 1:
	~~11 -~~ PONTEIROS		=PONTEIROS=


	Uma das características mas poderosas oferecidas pela linguagem C é o uso de ponteiros. Mas também é visto como um do tópicos mais complexos da linguagem. Isto ocorre principalmente porque os conceitos embutidos em ponteiros podem ser novos para muitos programadores (tendo-se em vista que nem todas as linguagens utilizam ponteiros), mas também porque os símbolos usados para notação de ponteiros em C não são tão claros; por exemplo, o mesmo símbolo ("*") é usado para duas diferentes finalidades.		Uma das características mas poderosas oferecidas pela linguagem C é o uso de ponteiros.

			Mas também é visto como um do tópicos mais complexos da linguagem.

			Isto ocorre principalmente porque os conceitos embutidos em ponteiros podem ser novos para muitos programadores (tendo-se em vista que nem todas as linguagens utilizam ponteiros), mas também porque os símbolos usados para notação de ponteiros em C não são tão claros; por exemplo, o mesmo símbolo ("*") é usado para duas diferentes finalidades.

	Mas, o que são ponteiros?		Mas, o que são ponteiros?
	Ponteiros proporcionam um modo de acesso a variáveis sem referenciá-las diretamente, através do seu endereço. Basicamente, um ponteiro é uma representação simbólica de um endereço.
			Ponteiros proporcionam um modo de acesso a variáveis sem referenciá-las diretamente, através do seu endereço.

			Basicamente, um ponteiro é uma representação simbólica de um endereço.

	Para declarar uma variável como ponteiro, a sintaxe é:		Para declarar uma variável como ponteiro, a sintaxe é:

	tipo * nome_da_variável;		''tipo * nome_da_variável;''

			onde ''tipo'' é o tipo de variável para qual o ponteiro vai apontar e ''nome_da_variável'' é o nome do ponteiro.

			Ou seja, a variável ponteiro ''nome_da_variável'' vai conter o endereço de uma outra variável do tipo tipo.

	onde tipo é o tipo de variável para qual o ponteiro vai apontar e nome_da_variável é o nome do ponteiro. Ou seja, a variável ponteiro nome_da_variável vai conter o endereço de uma outra variável do tipo tipo. Além disto, quando quisermos definir o ponteiro, utilizaremos o operador "&" para atribuir "o endereço de" uma variável ao ponteiro.		Além disto, quando quisermos definir o ponteiro, utilizaremos o operador "&" para atribuir "o endereço de" uma variável ao ponteiro.
	Ex:
			====Ex:====

	int * pont_i ; //pont_i é um ponteiro para variáveis int		int * pont_i ; //pont_i é um ponteiro para variáveis int
	float * pont_f; //pont_f é um ponteiro para variáveis float		float * pont_f; //pont_f é um ponteiro para variáveis float
Linha 17:		Linha 32:
	pont_i = &i; // coloca o endereço de i em pont_i		pont_i = &i; // coloca o endereço de i em pont_i

	A variável pont_i agora "aponta para i". ~~Caso precisemos acessar o conteúdo do endereço apontado por pont_i, ou seja, o conteúdo de i, utilizaremos o operador "*", que neste caso significa "valor no endereço de":~~		A variável ''pont_i'' agora "aponta para i".

	*pont_i = 5; // coloca 5 no endereço apontado por pont_i (i=5)		Caso precisemos acessar o conteúdo do endereço apontado por pont_i, ou seja, o conteúdo de i, utilizaremos o operador "*", que neste caso significa "valor no endereço de":

			*pont_i = 5; //coloca 5 no endereço apontado por pont_i (i=5)

	Os ponteiros podem ser inicializados já na declaração, como qualquer variável:		Os ponteiros podem ser inicializados já na declaração, como qualquer variável:
Linha 25:		Linha 42:
	int *pi = &i;		int *pi = &i;

	Além disto, os ponteiros podem ser utilizados na maioria das expressões válidas em C.		Além disto, os ponteiros podem ser utilizados na maioria das expressões válidas em C.
	Ponteiros são usados em situações em que a passagem de valores é
			Ponteiros são usados em situações em que a passagem de valores é é difícil ou indesejável.

			Algumas razões para o uso de ponteiros são:

	#fornecem maneiras com as quais as funções podem realmente modificar os argumentos que recebem;		#fornecem maneiras com as quais as funções podem realmente modificar os argumentos que recebem;
Linha 35:		Linha 55:
	#a notação de ponteiros compila muito mais rapidamente, tornando o código mais eficiente.		#a notação de ponteiros compila muito mais rapidamente, tornando o código mais eficiente.

	Outra coisa muito importante, é lembrar que podemos passar vários valores como argumentos para uma função, porém apenas sabemos como retornar um único valor (através do comando "return"). Mas como fazer para que uma função altere mais de um valor para a função chamadora? Visto que não há mecanismos próprios para isto, devemos contar com o uso de ponteiros.		Outra coisa muito importante, é lembrar que podemos passar vários valores como argumentos para uma função, porém apenas sabemos como retornar um único valor (através do comando "return").
	Ex:
			Mas como fazer para que uma função altere mais de um valor para a função chamadora?

			Visto que não há mecanismos próprios para isto, devemos contar com o uso de ponteiros.

			====Ex:====
	#include <stdio.h>		#include <stdio.h>
	void main(void)		void main(void)
Linha 45:		Linha 70:
	py = &y;		py = &y;
	printf(" O endereço de x é: %u, e o de y é: %u \n", px, py);		printf(" O endereço de x é: %u, e o de y é: %u \n", px, py);
	px = px + 10; // pode-se usar *px += 10;		px = px + 10; // pode-se usar *px += 10;
	py = py + 10; // e também (*py ) +=10		py = py + 10; // e também (*py ) +=10
	printf(" Agora x é: %d e y é: %d \n", x, y);		printf(" Agora x é: %d e y é: %d \n", x, y);
	printf(" ... e agora px aponta ~~para:~~ %u, e py ~~para:~~ %u\n", ++px, ++py);		printf(" ... agora px aponta p/ %u, e py p/ %u\n", ++px, ++py);
	printf(" ... que contém os valores: %d, %d \n", px, py);		printf(" ... que contém os valores: %d, %d \n", px, py);
	}		}

	Um operador "&" pode ser aplicado somente a variáveis e elementos de matrizes. Construções tais com "&(x+1)" e "&(3)" são ilegais.		Um operador "&" pode ser aplicado somente a variáveis e elementos de matrizes.

			Construções tais com "&(x+1)" e "&(3)" são ilegais.

	Ponteiros são sempre inicializados com o valor 0 (NULL) que não é um endereço válido, obrigando portanto, que inicializemos sempre nossos ponteiros antes de utilizá-los.		Ponteiros são sempre inicializados com o valor 0 (NULL) que não é um endereço válido, obrigando portanto, que inicializemos sempre nossos ponteiros antes de utilizá-los.

			==PONTEIROS E MATRIZES==

	~~=PONTEIROS E MATRIZES=~~		Existe uma correspondência muito grande entre ponteiros e matrizes.
			O nome de uma matriz é equivalente ao endereço do primeiro elemento na matriz. Como isto é imutável, podemos chamar o nome de uma matriz de "ponteiro constante". Já um ponteiro comum tem conteúdo variável, pode conter qualquer endereço, sendo porisso chamado de "ponteiro variável". Pode-se fazer, portanto:
	Existe uma correspondência muito grande entre ponteiros e matrizes. O nome de uma matriz é equivalente ao endereço do primeiro elemento na matriz. Como isto é imutável, podemos chamar o nome de uma matriz de "ponteiro constante". Já um ponteiro comum tem conteúdo variável, pode conter qualquer endereço, sendo porisso chamado de "ponteiro variável". Pode-se fazer, portanto:
	int imat[5] = {5,7,31,18,22};		int imat[5] = {5,7,31,18,22};
	int *ip;		int *ip;