ManipulacaoCaracter

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define true 1
#define false 0
//*******************************************************************************
//nome: contaCaracteres
//tipo: funcao
//retorno: unsigned int - numero de caracteres
//parametros:
// por valor: nenhum
// por referencia:
// const char* txt - o texto
//Descricao: esta rotina conta o numero de caracteres em um texto
//*******************************************************************************
unsigned int contaCaracteres(const char* txt)
{
 unsigned int cont = 0;
 while(txt[cont] != '\0')
 cont++;
 return cont;
}
//***********************************************************************************
//nome: contaCaracter
//tipo: funcao
//retorno: unsigned int - quantas vezes o caracter esta no texto
//parametros
// const char* txt - o texto (referencia)
// const char c - o caracter (valor)
//Descricao: percorre o texto txt contando as vezes que o caracter c
// esta presente.
//************************************************************************************
unsigned int contaCaracter(const char* txt, const char aux)
{
 int pos=0;
 unsigned int cont = 0;
 while(txt[pos] != '\0')
 {
 if(txt[pos] == aux)
 cont++;
 pos++;
 }
 return cont;
}
//*******************************************************
//nome:contaVogais
//tipo: função
//retorno: unsigned int - total de vogais no texto
//parametros
// char* txt - o texto a ser pesquisado
//Descrição: Descobre quantas vogais existe no texto
//*******************************************************
unsigned int contaVogais(const char* txt)
{
 int pos=0;
 unsigned int cont = 0;
 while(txt[pos] != '\0')
 {
 if(txt[pos] == 'a' || txt[pos] == 'A' ||
 txt[pos] == 'e' || txt[pos] == 'E' ||
 txt[pos] == 'i' || txt[pos] == 'I' ||
 txt[pos] == 'o' || txt[pos] == 'O' ||
 txt[pos] == 'u' || txt[pos] == 'U')
 cont++;
 pos++;
 }
 return cont;
}
//************************************************************.
//nome: tipoCaracter
//retorno : int
// 1 é vogal
// 2 é consoante
// 3 é outro caracter da tabela ASCII
//parametros:
// por valor: char aux - o caracter a ser identificado
//Descrição: identifica se o caracter é uma vogal, consoante
//ou um outro caracter da tabela ASCII
//*************************************************************
int tipoCaracter(char aux)
{
 if((aux>='A' && aux<='Z') || (aux>='a' && aux<='z'))
 {
 if(aux=='a' || aux=='e' || aux=='i' || aux=='o' || aux=='u'
 || aux=='A' || aux=='E' || aux=='I' || aux=='O' || aux=='U')
 {
 return 1;
 }
 else
 return 2;
 }
 else
 {
 return 3;
 }
}
//****************************************************************
//nome: toLower
//tipo: funcao
//retorno:char
//parametros:
// por valor - char aux
//Descricao: transforma em minusculo
//****************************************************************
char toLower(char aux)
{
 if(aux>= 'A' && aux<='Z')
 {
 aux = aux+32;
 return aux;
 }
 else
 return aux;
}
//****************************************************************
//nome: toUpper
//tipo: funcao
//retorno:char
//parametros:
// por valor - char aux
//Descricao: transforma em maiusculo
//****************************************************************
char toUpper(char aux)
{
 if (aux>='a' && aux<='z')
 {
 aux = aux-32;
 return aux;
 }
 else
 return aux;
}
//*************************************************************************
//nome: imprimaTabelaAscII
//tipo: procedimento
//retorno: nenhum
//parametros:
// por valor: nenhum
// por referencia: nenhum
//descricao: imprime a Tabela ASCII na tela.
//*************************************************************************
void imprimeTabelaASCII()
{
 int pos;
 for(pos=1; pos<256; pos++)
 printf("\n%i = %c",pos, pos);
}
//*************************************************************************
//nome: toUpperTexto
//tipo: procedimento
//retorno: nada
//parametros:
// por referencia: char* txt
//descricao: transforma o texto recebido em maiusculo
//*************************************************************************
void toUpperTexto(char* txt)
{
 char aux;
 int pos=0;
 while(txt[pos] !='\0')
 {
 aux=toUpper(txt[pos]);
 txt[pos]= aux;
 pos++;
 }
}
//*************************************************************************
//nome: toLowerTexto
//tipo: procedimento
//retorno: nada
//parametros:
// por referencia: char* txt
//descricao: transforma o texto recebido em minusculo
//*************************************************************************
void toLowerTexto(char* txt)
{
 char aux;
 int pos=0;
 while(txt[pos] !='\0')
 {
 aux=toLower(txt[pos]);
 txt[pos]= aux;
 pos++;
 }
}
//**************************************************************
//nome: Menu
//tipo: função
//retorno: int
//parametros:
// por valor: nenhum - nada
// por referência: nenhum - nada
//Descrição: esta rotina interage com o usuário socilitando a
//operação que ele deseja realizar.
//**************************************************************
int Menu()
{
 int a;
 printf("\nMenu\n");
 printf("\n1 - Descobrir quantos caracteres existem no nome");
 printf("\n2 - Descobrir quantas vezes um determinado caracter esta presente no nome");
 printf("\n3 - Descobrir quantas vogais existe no nome");
 printf("\n4 - Imprimir a Tabela ASCII na tela");
 printf("\n5 - Descobrir o tipo do caracter");
 printf("\n6 - Transformar o caracter em maiusculo");
 printf("\n7 - Transformar o caracter em minusculo");
 printf("\n8 - Transformar um texto em maiusculo");
 printf("\n9 - Transformar um texto em minusculo");
 printf("\n0 - Finalizar o programa\n");
 fflush(stdin);
 scanf("%i", &a);
 if(a==1 || a==2 || a==3 || a==4 ||
 a==5 || a==6 || a==7 || a==8 ||
 a==9 || a==0)
 return a;
 else
 printf("\ninvalido\n");
}
//************************************************************************
//Nome:obtemCaracter
//Tipo:procedimento
//Retorno: nada
//Parâmetros:
// por valor:
// por referência: char*aux
//Descrição:interage com o usuario solicitando o caracter
//************************************************************************
void obtemCaracter(char*aux)
{
 printf("\nDigite 1 caracter: ");
 fflush(stdin);
 scanf("%c",aux);
}
//************************************************************************
//Nome:obtemTexto
//Tipo:procedimento
//Retorno: nada
//Parâmetros:
// por valor:
// por referência:char*txt
//Descrição:interage com o usuario solicitando o texto.
//************************************************************************
void obtemTexto(char*txt)
{
 printf("\nDigite o texto:");
 fflush(stdin);
 gets(txt);
}
//************************************************************************
//Nome:obtemNOme
//Tipo:procedimento
//Retorno: nada
//Parâmetros:
// por valor:
// por referência:char*txt
//Descrição:interage com o usuario solicitando o nome.
//************************************************************************
void obtemNome(char*txt)
{
 printf("\nDigite o nome:");
 fflush(stdin);
 gets(txt);
}
//************************************************************************
//Nome:gerente
//Tipo:procedimento
//Retorno: nada
//Parâmetros:
// por valor:
// por referência:
//Descrição:Gerencia o programa.
//************************************************************************
void gerente()
{
 char txt[100];
 int escolha, aux1;
 char aux;
 do
 {
 escolha = Menu();
 switch(escolha)
 {
 case 1:
 obtemNome(txt);
 printf("\n\n Seu nome possui %u caracteres\n\n", contaCaracteres(txt));
 break;
 case 2:
 obtemNome(txt);
 obtemCaracter(&aux);
 printf("\n\nSeu nome tem %u letras %c\n\n", contaCaracter(txt, aux),aux);
 break;
 case 3:
 obtemNome(txt);
 printf("\n\nSeu nome tem %u vogais\n\n", contaVogais(txt));
 break;
 case 4:
 imprimeTabelaASCII();
 break;
 case 5:
 obtemCaracter(&aux);
 tipoCaracter(aux);
 switch(tipoCaracter(aux))
 {
 case 1:
 printf("\n\n%c = vogal\n\n",aux);
 break;
 case 2:
 printf("\n\n %c = consoante\n\n", aux);
 break;
 case 3:
 printf("\n\n %c nao pertence as letras \n\n", aux);
 break;
 }
 break;
 case 6:
 obtemCaracter(&aux);
 printf("\n\nLetra maiuscula = %c \n\n", toUpper(aux));
 break;
 case 7:
 obtemCaracter(&aux);
 printf("\n\nLetra minuscula = %c \n\n", toLower(aux));
 break;
 case 8:
 obtemTexto(txt);
 toUpperTexto(txt);
 aux1=0;
 while(txt[aux1]!='\0')
 {
 printf("%c",txt[aux1]);
 aux1++;
 }
 break;
 case 9:
 obtemTexto(txt);
 toLowerTexto(txt);
 aux1=0;
 while(txt[aux1]!='\0')
 {
 printf("%c", txt[aux1]);
 aux1++;
 }
 break;
 case 0:
 exit(0);
 default:
 printf("\n\nErro - operacao desconhecida\n\n");
 }
 }while(true);
}
int main()
{
 gerente();
 return 0;
}