Ir ao conteúdo
  • Cadastre-se

Main.cpp

Membros Plenos
  • Total de itens

    288
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

81

Sobre Main.cpp

  • Data de Nascimento 21-02-1970 (49 anos)

Informações gerais

  • Cidade e Estado
    Guarulhos
  • Sexo
    Masculino
  1. Aqui está um exemplo de como ler uma linha específica dentro de um arquivo, o código é didático e indicado a estudantes de linguagem C. https://codigosfontes-ccplus-plus.blogspot.com/2019/04/arquivo-escolhendo-linha-para-leitura.html /*============================================================================*/ int main ( ) { system ( "title LENDO UMA LINHA ESPECÍFICA NUM ARQUIVO" ); char **nomes; nomes = ( char** ) malloc ( 80 * sizeof ( char* ) ); Moldura ( 2, 25, 3, 79 ); textcolor ( LIGHTRED ); gotoxy ( 23 , 3 ); printf ( "LENDO UMA LINHA ESPECÍFICA NUM ARQUIVO" ); textcolor ( LIGHTBLUE ); gotoxy ( 7 , 5 ); printf ( "Nomes do arquivo" ); Ler_Arquivo ( nomes ); free ( nomes ); return ( 0 ); } /*============================================================================*/
  2. Programa criado numa sexta-feira, 14 de novembro de 2014 Este programa cria um arquivo binário contendo uma matriz de string, Em seguida faz-se uma leitura onde operações importantes são feitas. São elas: Contagem de todos os caracteres encontrados, Contagem de vogais minúscula e maiúscula, uma por uma, Conta todas as vogais encontradas entre maiúscula e minúscula, Conta também o total de espaços e de consoantes encontradas no arquivo. Programa indicado aos iniciantes de linguagem c. Abaixo uma imagem do programa em execução: Abaixo o código do programa: http://codigosfontes-ccplus-plus.blogspot.com/2014/11/arquivo-contando-vogais-consoantes-e.html #include <stdio.h> #include <conio.h> void Janela5() { system("Color F0"); int lin, col; for (lin = 0; lin <= 25; lin++) { for (col = 0; col <= 80; col++) { gotoxy(col, lin); if (lin == 2) { textbackground(LIGHTBLUE); printf(" "); } if (col == 1) { textbackground(LIGHTBLUE); printf(" "); } if (lin == 25) { textbackground(LIGHTBLUE); } if (col == 80) { textbackground(LIGHTBLUE); printf(" "); } } } textbackground(BLACK); } void inicio() { system("title ARQUIVO : CONTANDO VOGAIS CONSOANTES E ESPAÇOS"); int i; do { Janela5(); textbackground(WHITE); textcolor(LIGHTRED); gotoxy(20, 7); printf("ARQUIVO : CONTANDO VOGAIS CONSOANTES E ESPAÇOS"); textcolor(BROWN); gotoxy(25, 10); printf("Programa desenvolvido por:"); textcolor(BLACK); gotoxy(52, 10); printf("Samuel Lima"); textcolor(BLUE); gotoxy(34, 12); printf("sa_sp10@hotmail.com"); textcolor(LIGHTBLUE); gotoxy(24, 14); printf("DIGITE PARA SAIR OU PARA CONTINUAR "); textcolor(LIGHTRED); gotoxy(32, 14); printf("1"); textcolor(LIGHTRED); gotoxy(47, 14); printf("2"); gotoxy(41, 16); scanf("%d", &i); fflush(stdin); if (i == 1) { textcolor(LIGHTRED); gotoxy(35, 20); printf("MUITO OBRIGADO"); Sleep(1800); exit(0); } if (i == 2) { system("cls"); return; } else { textcolor(LIGHTRED); gotoxy(37, 20); printf("\aOPÇÃO ERRADA"); Sleep(1800); system("cls"); } } while (i); } int main() { inicio(); Janela5(); textbackground(WHITE); char ch = 0; FILE *arq; int totvogmi = 0, totvogma = 0, totacet = 0, totced = 0, totcon = 0, totcar = 0; int j, t, et = 0, ced = 0, ced01 = 0, a = 0, e = 0, i = 0, o = 0, u = 0, A = 0, E = 0, I = 0, O = 0, U = 0, a0 = 0, a01 = 0, a02 = 0, a03 = 0, e01 = 0, e02 = 0, i01 = 0, o01 = 0, o02 = 0, o03 = 0, u01 = 0, u02 = 0, A0 = 0, A01 = 0, A02 = 0, A03 = 0, E01 = 0, E02 = 0, I01 = 0, O01 = 0, O02 = 0, O03 = 0, U01 = 0, U02 = 0; char linha[11][17] = {{"João Eugênio" }, { "Átila Antônio" }, {"Irene Patrícia" }, { "Mônica Simões" }, { "Ester Büeno" }, { "Graça Núbia" }, { "Fábio Júnior" }, { "Ozéias Gonçalo" }, { "Lúcia Píres" }, { "Ulisses Ângelo" }, { "Ítalo Guimarães"}}; if ((arq = fopen("Arquivo.bin", "w+b")) == NULL) { printf("Houve um erro na criação do arquivo"); getche(); exit(1); } if (fwrite(&linha, sizeof(linha), 1, arq) != 1) { printf("Houve um erro na gravação do arquivo"); getche(); exit(1); } fclose(arq); if ((arq = fopen("Arquivo.bin", "r+b")) == NULL) { printf("Houve um erro na abertura do arquivo"); getche(); exit(1); } if (fread(&linha, sizeof(linha), 1, arq) != 1) { printf("Houve um erro na leitura do arquivo"); getche(); exit(1); } system("cls"); Janela5(); textbackground(WHITE); textcolor(LIGHTRED); gotoxy(20, 3); printf("ARQUIVO : CONTANDO VOGAIS CONSOANTES E ESPAÇOS"); textcolor(LIGHTRED); gotoxy(9, 5); printf("Nomes no arquivo"); textcolor(LIGHTRED); gotoxy(52, 5); printf("Conteúdo do arquivo"); for (t = 0; t < 11; t++) { gotoxy(5, t + 7); textcolor(BLACK); for (j = 0; j < 17; j++) { printf(" %c", linha[t][j]); } textcolor(LIGHTRED); printf(" %d ", strlen(linha[t])); totcar += strlen(linha[t]); } fclose(arq); if ((arq = fopen("Arquivo.bin", "r + b")) == NULL) { printf("Houve um erro na abertura do arquivo"); ch = EOF; getche(); exit(1); } while (ch != EOF) { ch = fgetc(arq); if (ch == 'a') a++; if (ch == 'e') e++; if (ch == 'i') i++; if (ch == 'o') o++; if (ch == 'u') u++; if (ch == 'A') A++; if (ch == 'E') E++; if (ch == 'I') I++; if (ch == 'O') O++; if (ch == 'U') U++; if (ch == 'à') a0++; if (ch == 'á') a01++; if (ch == 'ã') a02++; if (ch == 'â') a03++; if (ch == 'é') e01++; if (ch == 'ê') e02++; if (ch == 'í') i01++; if (ch == 'ó') o01++; if (ch == 'õ') o02++; if (ch == 'ô') o03++; if (ch == 'ú') u01++; if (ch == 'ü') u02++; if (ch == 'À') A0++; if (ch == 'Ã') A01++; if (ch == 'Á') A02++; if (ch == 'Á') A03++; if (ch == 'É') E01++; if (ch == 'Ê') E02++; if (ch == 'Í') I01++; if (ch == 'Ó') O01++; if (ch == 'Õ') O02++; if (ch == 'Ô') O03++; if (ch == 'Ú') U01++; if (ch == 'Ü') U02++; if (ch == 'ç') ced++; if (ch == 'Ç') ced01++; if (ch == ' ') et++; } totvogmi = (a + e + i + o + u); totvogma = (A + E + I + O + U); totacet = (a0 + a01 + a02 + a03 + e01 + e02 + i01 + o01 + o02 + o03 + u01 + u02 + A0 + A01 + A02 + A03 + E01 + E02 + I01 + O01 + O02 + O03 + U01 + U02); totced = (ced + ced01); totcon = totcar - (totvogmi + totvogma + totacet + totced); fclose(arq); textcolor(BLACK); gotoxy(50, 7); printf("vogais a minúsculo = "); textcolor(LIGHTRED); printf("%d", a); textcolor(BLACK); gotoxy(50, 8); printf("vogais e minúsculo = "); textcolor(LIGHTRED); printf("%d", e); textcolor(BLACK); gotoxy(50, 9); printf("vogais i minúsculo = "); textcolor(LIGHTRED); printf("%d", i); textcolor(BLACK); gotoxy(50, 10); printf("vogais o minúsculo = "); textcolor(LIGHTRED); printf("%d", o); textcolor(BLACK); gotoxy(50, 11); printf("vogais u minúsculo = "); textcolor(LIGHTRED); printf("%d", u); textcolor(BLACK); gotoxy(50, 12); printf("vogais A maiúsculo = "); textcolor(LIGHTRED); printf("%d", A); textcolor(BLACK); gotoxy(50, 13); printf("vogais E maiúsculo = "); textcolor(LIGHTRED); printf("%d", E); textcolor(BLACK); gotoxy(50, 14); printf("vogais I maiúsculo = "); textcolor(LIGHTRED); printf("%d", I); textcolor(BLACK); gotoxy(50, 15); printf("vogais O maiúsculo = "); textcolor(LIGHTRED); printf("%d", O); textcolor(BLACK); gotoxy(50, 16); printf("vogais U maiúsculo = "); textcolor(LIGHTRED); printf("%d", U); textcolor(BLACK); gotoxy(50, 17); printf("total de espaços = "); textcolor(LIGHTRED); printf("%d", et); textcolor(BLACK); gotoxy(50, 18); printf("Cedilhas minúscula = "); textcolor(LIGHTRED); printf("%d", ced); textcolor(BLACK); gotoxy(50, 19); printf("Cedilhas maiúscula = "); textcolor(LIGHTRED); printf("%d", ced01); textcolor(BLACK); gotoxy(5, 19); printf("Todas consoantes = "); textcolor(LIGHTRED); printf("%d", totcon); textcolor(BLACK); gotoxy(5, 20); printf("vogais minúscula = "); textcolor(LIGHTRED); printf("%d", totvogmi); textcolor(BLACK); gotoxy(5, 21); printf("vogais maiúscula = "); textcolor(LIGHTRED); printf("%d", totvogma); textcolor(BLACK); gotoxy(5, 22); printf("Todos acentuados = "); textcolor(LIGHTRED); printf("%d", totacet); textcolor(BLACK); gotoxy(5, 23); printf("Todos as cedilhas = "); textcolor(LIGHTRED); printf("%d", totced); textcolor(BLACK); gotoxy(50, 21); printf("Todos Caracteres = "); textcolor(LIGHTRED); printf("%d", totcar); Sleep(1800); textcolor(LIGHTRED); gotoxy(50, 23); printf("MUITO OBRIGADO"); getche(); return (0); }
  3. Estas indentações são feitas pelo eclipse, geralmente seleciono todo o código e escolho a opção Source -> Correct indetation, e o resto ele faz.. Espero que tenha visualizado o código completo no blog.
  4. Matriz transposta é uma matriz invertida, em relação a matriz original, as linhas da matriz original, passarão a ser as colunas da matriz transposta, e as colunas da matriz original passarão a ser as linhas da matriz transposta. Se você já domina matrizes não terá dificuldades em entender o que é matriz transposta. Acompanhe agora mesmo este exemplo: /*============================================================================*/ int main ( ) { int M [ tam ] [ tam ], N [ tam ] [ tam ]; char letra = '\0'; system ( "title MATRIZ TRANSPOSTA" ); matriz_transposta ( ); Moldura ( 2, 25, 3, 79 ); textbackground ( WHITE ); textcolor ( LIGHTRED ); gotoxy ( 32, 3 ); printf ( "MATRIZ TRANSPOSTA II" ); textcolor ( LIGHTBLUE ); gotoxy ( 26, 5 ); printf ( "Mostrando abaixo a matriz " ); textcolor ( LIGHTRED ); printf ( "%d", n ); textcolor ( LIGHTBLUE ); printf ( " por " ); textcolor ( LIGHTRED ); printf ( "%d", m ); textcolor ( LIGHTBLUE ); Cria_Matriz ( M ); Imprime_Matriz ( M, N ); //Este bloco só permite a passagem pela tecla ENTER //Se alum caractere for digitado, um beep é acionado do { textcolor ( LIGHTBLUE ); gotoxy ( 18, 21 ); printf ( "Foram gerados " ); textcolor ( LIGHTRED ); printf ( "%d", a ); textcolor ( LIGHTBLUE ); printf ( " elementos na matriz sem repetições" ); Informe ( ); letra = getch ( ); fflush ( stdin ); if ( letra == ENTER ) { k = true; } if ( letra != ENTER ) { Beep ( 1000, 500 ); } continue; }while ( letra != ENTER ); Moldura ( 2, 25, 3, 79 ); textbackground ( WHITE ); textcolor ( LIGHTRED ); gotoxy ( 32, 3 ); printf ( "MATRIZ TRANSPOSTA II" ); textcolor ( LIGHTBLUE ); gotoxy ( 27, 5 ); printf ( "A diagonal da matriz " ); textcolor ( LIGHTRED ); printf ( "%d", m ); textcolor ( LIGHTBLUE ); printf ( " por " ); textcolor ( LIGHTRED ); printf ( "%d", n ); gotoxy ( 27, 6 ); textcolor ( LIGHTBLUE ); printf ( "transposta foi multiplicada por " ); textcolor ( LIGHTRED ); printf ( "%d", b ); Imprime_Matriz ( M, N ); Informe ( ); getche ( ); exit ( 0 ); } /*============================================================================*/
  5. Entre os três blogs que posuo, que são: Java/JavaFX, C/C++ e C++ builder, C/C++ domina nas visualizações e procura, então ainda vale a pena escrever códigos em C/C++. Aqui posto um exemplo de como obter a diagonal de uma matriz multiplicada por um número inserido pela entrada de dados com teclado. A diagonal é imprimida em destaque, e o código é indicado aos interessados por linguagem C, mas que ainda não sabe como fazer isto. int main ( ) { system ( "title MATRIZ - MULTIPLICANDO A DIAGONAL PRINCIPAL" ); Moldura ( 2 , 25 , 2 , 79 , 2 , 3 ); int l, c, d; bool x = false; int matriz [ tam ] [ tam ], dl = 0, dc = 0; textcolor ( LIGHTRED ); gotoxy ( 20 , 3 ); printf ( "MATRIZ - MULTIPLICANDO A DIAGONAL PRINCIPAL" ); textcolor ( LIGHTBLUE ); gotoxy ( 21 , 5 ); printf ( "Digite " ); textcolor ( LIGHTRED ); printf ( "9" ); textcolor ( LIGHTBLUE ); printf ( " valores para inserir na matriz" ); Tabela ( ); for ( l = 1; l <= tam ; l++ ) { dc = 0; for ( c = 1; c <= tam ; c++ ) { if ( l == c ) { textcolor ( LIGHTRED ); textbackground ( WHITE ); x = true; } else textbackground ( WHITE ); gotoxy ( 31 + dc , 9 + dl ); scanf ( "%d" , &matriz [ l ] [ c ] ); textcolor ( LIGHTBLUE ); dc = dc + 10; } dl = dl + 5; } if ( x == true ) { textcolor ( LIGHTBLUE ); gotoxy ( 20 , 24 ); printf ( "Multiplicar a diagonal principal por: " ); textcolor ( LIGHTRED ); scanf ( "%d" , &d ); } system ("cls"); Moldura ( 2 , 25 , 2 , 79 , 2 , 3 ); textcolor ( LIGHTRED ); gotoxy ( 20 , 3 ); printf ( "MATRIZ - MULTIPLICANDO A DIAGONAL PRINCIPAL" ); gotoxy ( 23 , 5 ); textcolor ( LIGHTBLUE ); printf ( "Abaixo a diagonal multiplicada por: "); textcolor ( LIGHTRED ); gotoxy ( 59 , 5 ); printf ( "%d", d ); Tabela ( ); for ( l = 1; l <= tam ; l++ ) { dc = 0; for ( c = 1; c <= tam ; c++ ) { if ( l == c ) { matriz [ l ] [ c ] = matriz [ l ] [ c ] * d; textcolor ( LIGHTRED ); textbackground ( WHITE ); } else textbackground ( WHITE ); gotoxy ( 30 + dc , -6 + dl ); printf ( "%3d", matriz [ l ] [ c ] ); textcolor ( LIGHTBLUE ); dc = dc + 10; } dl = dl + 5; } Sleep ( 1800 ); textcolor ( LIGHTRED ); gotoxy ( 35 , 24 ); printf ( "MUITO OBRIGADO" ); getche ( ); } https://codigosfontes-ccplus-plus.blogspot.com/2019/04/matriz-multiplicando-diagonal-principal.html
  6. Estive com alguns pensamentos dentro de minha cabeça sobre algorítimos de ordenação, sim, isto me pertubou por uns bons minutos, e comecei a me perguntar, porque gastamos tanto tempo aprendendo sobre os algorítimos ordenadores existentes, alguns criados quando nós nem ainda éramos nascidos, isto faz algum sentido? Não podemos esconder de ninguém que somos curiosos por tecnologia, e vivemos respirando, para aprender ou pelo menos conhecer tudo sobre o assunto, mas nosso cérebro tem limites, as informações são adicionadas aos poucos, e algumas vezes nos sentimos frustrados por não pode dominar tudo o que gostaríamos de dominar. Não encontrei resposta melhor do que esta, mas se você conseguir por favor poste nos comentários para que possamos conhecer sua opinião. Resposta: Acelerar o processo de pesquisa no computador, otimizando a capacidade de acessar milhares de dados de forma eficiente, para que o desempenho da máquina não seja afetado enquanto estamos fazendo outras tarefas ao mesmo tempo em que programamos, ou ouvimos nossas músicas favoritas; Pra mim esta é a resposta, e aqui está um bom exemplo de uso do famoso método bubble sort para ordenação de um vetor de inteiros carregado por um loop for, e embaralhado para podermos aplicar a ordenação. https://codigosfontes-ccplus-plus.blogspot.com/2019/04/ordenando-um-vetor-com-bubble-sort.html /*============================================================================*/ int main ( ) { system ( "title ORDENANDO UM VETOR COM BUBBLE SORT" ); Moldura ( 2, 25, 3, 79 ); textbackground ( WHITE ); int vet [ TAM ]; Cria_Vetor ( vet ); textcolor ( LIGHTBLUE ); gotoxy ( 25 , 5 ); printf ( "Vetor gerado desordenado" ); Imprime_Vetor ( vet ); bubble_sort ( vet, TAM ); textcolor ( LIGHTBLUE ); gotoxy ( 25 , 5 ); printf ( "Vetor ordenado por bubble sort" ); Imprime_Vetor ( vet ); Sleep ( 1800 ); Informe ( ); getche ( ); return 0; } /*============================================================================*/
  7. Ordenação por fusão, que é um dos sinônimos em português da palavra "merge", ou mistura. é um tipo de ordenação de alta eficiência mas de grande complexidade para entender. Ficou popularmente dito que se deve dividir para conquistar, e seu funcionamento envolve recursividade, portanto um alto nível de memória deve ser notado pelo seu tempo de execução acima de outros, concorrentes, mesmo assim em alguns casos o uso é recomendado. Veja abaixo imagens do programa em execução: /*============================================================================*/ int main ( ) { system ( "title ORDENANDO UM VETOR COM MERGE SORT" ); Moldura ( 2, 25, 2, 79 ); textbackground ( WHITE ); int vet [ TAM ]; Cria_Vetor ( array ); textcolor ( LIGHTBLUE ); gotoxy ( 25 , 5 ); printf ( "Vetor gerado desordenado" ); Imprime_Vetor ( vet ); merge_sort ( vet, TAM ); textcolor ( LIGHTBLUE ); gotoxy ( 25 , 5 ); printf ( "Vetor ordenado por merge sort" ); Imprime_Vetor ( vet ); Sleep ( 1800 ); Informe ( ); getche ( ); return 0; } /*============================================================================*/ https://codigosfontes-ccplus-plus.blogspot.com/2019/04/ordenando-um-vetor-com-merge-sort.html
  8. Vou criar um post, depois você implementa no seu programa. Entenda que não foi eu que criei o merge sort, quem dera, somos nada, apenas utilizamos em nossos programas, aproveite e veja a parte teórica do merge sort, vantagem e desvantagens.
  9. Aqui vai um exemplo de quick sort implementado no código do autor do tópico, já havia passado um exemplo mas ele não aceitou, talvez por achar complicado. //Ordenação com quick sort #include <stdio.h> #include <conio.h> #include <stdlib.h> #define TAM 100 void Quick_Sort ( int vetor [ TAM ], int ini, int fim ) { int temp, men, mar; int aux, met; men = ini; mar = fim; met = ( int ) ( ( men + mar ) / 2 ); temp = vetor [ met ]; do { while ( vetor [ men ] < temp ) men = men + 1; while ( vetor [ mar ] > temp ) mar = mar - 1; if ( men <= mar ) { aux = vetor [ men ]; vetor [ men ] = vetor [ mar ]; vetor [ mar ] = aux; men = men + 1; mar = mar - 1; } } while ( mar > men ); if ( ini < mar ) Quick_Sort ( vetor, ini, mar ); if ( men < fim ) Quick_Sort ( vetor, men, fim ); } int main ( ) { int i, tm; int *A; printf ( "Digite o tamanho da entrada : " ); scanf ( "%d", &tm ); A = ( int* ) malloc ( sizeof ( int ) * TAM ); printf ( "Digite os numeros:\n" ); for ( i = 1; i <= tm; i++ ) { scanf ( "%d", &A [ i ] ); } printf ( "\n" ); Quick_Sort ( A, 1, tm + 1 ); printf ( "numeros ordenados crescente :\n" ); for ( i = 1; i < tm + 1; i++ ) { printf ( " %d", A [ i ] ); } printf ( "\n\n" ); getche ( ); return 0; } adicionado 43 minutos depois Só queria deixar claro uma coisa. Por mais que agente altere os nomes das variáveis, num código de ordenação, como este mesmo quick sort, que é tido como um dos mais produtivo no que faz, isto não quer dizer que somos os donos do código, as alterações dos nomes das variáveis ou algumas meras modificações no código original só satisfaz nossos gosto ou otimiza de acordo com o sistema usado. A história do quick sort é impressionante e foi desenvolvido em 1960 pelo cientista da computação britânico Charles Antony Richard Hoare, também conhecido como Tony Hoare ou C. A. R. Mas só após uma série de refinamentos o algoritmo foi publicado em 1962. Aqui está um link falando sobre o quick sort, mas com certeza deve existir dezenas sobre o mesmo assunto publicado na internet. http://www.dsc.ufcg.edu.br/~pet/jornal/abril2013/materias/historia_da_computacao.html
  10. Tem certeza que este código está ordenando? numa entrada de 10, digite a seguinte sequência: 9081726354 Uma outra coisa, se não estou enganado isto está parecendo um bubble sort. Vou procurar um exemplo por aqui de um quick sort.
  11. O primeiro elemento que entra, é o último que sai, Baseado no princípio LIFO ( Last IN, First OUT ), ou o primeiro elemento inserido, será o último retirado. é assim que funciona uma pilha que é o inverso de fila. Os métodos principais de pilha são: push() para inserir elementos na pilha. top() para acessar elementos inserido na pillha. pop() para retirar um elemento do topo. empty() para verificar se a pilha está vazia ou não. Para mostrar o funcionamento de uma pilha, empilhamos 100 elementos inteiros num vetor, e desempilhamos invertendo a ordem destes elementos. Veja abaixo imagens do programa em execução: https://codigosfontes-ccplus-plus.blogspot.com/2019/04/pilha-invertendo-um-vetor-de-inteiros-ii.html /*============================================================================*/ int main ( ) { //Colocando um título no "cmd" SetConsoleTitle ( "PILHA - INVERTENDO UM VETOR DE INTEIROS" ); Moldura ( 2, 25, 2, 79 ); int vet [ 100 ]; int i; top = &cab; top -> prox = NULL; gotoxy ( 25 , 5 ); printf ( "Impressão normal do vetor " ); textcolor ( LIGHTGRAY ); Imprime_Pilha ( vet, top ); for ( i = 0; i < 100 ; i++ ) Empi_lha ( vet [ i ], top ); Moldura ( 2, 25, 2, 79 ); textcolor ( LIGHTBLUE ); gotoxy ( 25 , 5 ); printf ( "Vetor invertido pela pilha" ); Imprime_Pilha ( vet, top ); Sleep ( 1800 ); Informe ( ); getche ( ); exit ( 0 ); } /*============================================================================*/
  12. você cometeu outros erros bobos. com alguns concertos seu código ficou assim: "Now it is in your care" #include <stdio.h> #include <stdlib.h> #include <time.h> #define TAM 100 void preenche_aleatorio ( int *A, int n ) { int i; srand ( time ( NULL ) ); for ( i = 0; i < n; i++ ) { A [ i ] = rand ( ) % n; printf ( "%d\n", A [ i ] ); } } void preenche_crescente ( int *A, int n ) { int i; for ( i = 0; i < n; i++ ) { A [ i ] = i; printf ( "%d\n", A [ i ] ); } } void preenche_decrescente ( int *A, int n ) { int i; for ( i = 0; i < n; i++ ) { A [ i ] = n - i; printf ( "%d\n", A [ i ] ); } } void insertion ( int *A, int n ) { int chave = 0; int i, j = 0; for ( i = 1; i < n; i++ ) { chave = A [ i ]; j = i - 1; while ( j >= 0 && A [ j ] > chave ) { A [ j + 1 ] = A [ j ]; j = j - 1; } } A [ j + 1 ] = chave; } int main ( ) { int i, n, op; int* A; A = ( int* ) malloc ( TAM * sizeof ( int ) ); clock_t ti; clock_t tf; double segundos; do { printf ( "\n *****************MENU DE opções DO TEMPO POR CICLO INSERT SORT********************\n" ); printf ( "\n" ); printf ( "1-Preencher numeros aleatorio:\n" ); printf ( "2-Preencher numeros Crescente:\n" ); printf ( "3-Preencher numeros Decrescente:\n" ); printf ( "4-Sair:\n" ); printf ( "\n" ); printf ( "***Escolha o tipo de entrada:***\n" ); scanf ( "%d", &op ); if ( op != 4 ) { printf ( "Digite o tamanho da entrada:\n" ); scanf ( "%d", &n ); //A = ( int* ) malloc ( sizeof ( int ) * n ); } switch ( op ) { case 1: printf ( "1-Preencher numeros aleatorio:\n" ); preenche_aleatorio ( A, n ); ti = clock ( ); insertion ( A, n ); tf = clock ( ) - ti; segundos = ( ( double ) tf ) / CLOCKS_PER_SEC; for ( i = 0; i <= n - 1; i++ ) { printf ( "%d -", A [ i ] ); } printf ( "\n" ); printf ( "\nForam necessarios %d ciclos de clock (%lf segundos)", tf, segundos ); break; case 2: printf ( "2-Preencher numeros Crescente:\n" ); preenche_crescente ( A, n ); ti = clock ( ); insertion ( A, n ); tf = clock ( ) - ti; segundos = ( ( double ) tf ) / CLOCKS_PER_SEC; for ( i = 0; i <= n - 1; i++ ) { printf ( "%d -", A [ i ] ); } printf ( "\n" ); printf ( "\nForam necessarios %d ciclos de clock (%lf segundos)", tf, segundos ); break; case 3: printf ( "3-Preencher numeros Decrescente:\n" ); preenche_decrescente ( A, n ); ti = clock ( ); insertion ( A, n ); tf = clock ( ) - ti; segundos = ( ( double ) tf ) / CLOCKS_PER_SEC; for ( i = 0; i < n; i++ ) { printf ( "%d -", A [ i ] ); printf ( "\n" ); } printf ( "\n" ); printf ( "\n\tForam necessarios %d ciclos de clock (%lf segundos)", tf, segundos ); break; default: break; } } while ( op != 4 ); free ( A ); return 0; }
  13. Segue um link de um exemplo: O vetor é preenchido por um contador, e em seguida seus elementos são embaralhados para que possam passar por um bloco de ordenação com quick sort. https://codigosfontes-ccplus-plus.blogspot.com/2019/04/ordenando-vetor-com-quick-sort.html
  14. Quando precisamos saber o tamanho de variáveis ou de tipos, utilizamos o operador sizeof que tem a seguinte sintaxe: sizeof ( nome_da_variável ou_nome_do_tipo ); O que ele faz é retornar o tamanho do tipo ou da variável em bytes. É muito importante usá-lo para que a portabilidade seja atingida sem que tenha desperdícios de memória alocadas. Parece estranho dizer que sizeof seja um operador, mas se levarmos em conta que ele atua em tempo de execução sendo trocado pelo tamanho da variável ou do tipo, ficamos convencido de sua atuação. A função strlen, cuja sintaxe é: strlen ( string ); mostra em seu retorno o comprimento da string, mas fica em nossas mãos o cuidado com o terminador nulo no final da string, já que strlen não o inclui no comprimento. Uma string em C, é um vetor de string, então basta acrescentar um a mais no valor inteiro retornado por strlen. Aqui temos um bom exemplo de uso do operador sizeof e strlen. //--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include "Unit1.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; bool x = false; //--------------------------------------------------------------------------- #define SIZE 180 struct inf { char nomes [ 40 ]; char *name ; }; //--------------------------------------------------------------------------- void __fastcall TForm1::Informe ( TObject *Sender ) { Canvas -> Font -> Style = TFontStyles() << fsBold << fsUnderline << fsItalic ; Canvas -> Font -> Color = clBlack; Canvas -> TextOut ( 200, 210, "Por: " ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 240, 210, "Samuel Lima" ); Canvas -> Font -> Color = clBlack; Canvas -> TextOut ( 200, 230, "sa_sp10@hotmail.com" ); Canvas -> Font -> Name = "Garamond"; Canvas -> Font -> Size = 20; Canvas -> Font -> Color = clSkyBlue; Canvas -> TextOut ( 196, 256, "MUITO OBRIGADO" ); SetBkMode ( Canvas -> Handle, TRANSPARENT ); Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 190, 250, "MUITO OBRIGADO" ); } //--------------------------------------------------------------------------- void __fastcall TForm1::Inf_tam ( TObject *Sender ) { Canvas -> Font -> Style = TFontStyles ( ) << fsItalic; Canvas -> Font -> Size = 14; Canvas -> Font -> Name = "arial"; inf *pt; int i = 0, j = 0, t = 0; //abaixo alocando memória para a struct pt = ( inf* ) malloc ( SIZE *sizeof ( inf ) ); //abaixo alocando memória para o ponteiro name if ( ( pt -> name = ( char* ) malloc ( SIZE ) ) == NULL ) { //Criando um Label na mão TLabel* Label1 = new TLabel ( Form1 ); Label1 -> Parent = Form1; Label1 -> Left = 75; Label1 -> Top = 32; Label1 -> Caption = "Não foi possível alocar memória para name"; Beep ( 1000, 500 ); exit ( 1 ); } Canvas -> Font -> Size = 11; pt -> name = "Linguagem C"; Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 120, 35, "Valor do ponteiro name" ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 372, 35, AnsiString ( pt -> name ) ); for ( i = 0; i < strlen ( pt -> name ); i++ ) { if ( pt -> name [ i ] == ' ' ) t++; } j = strlen ( pt -> name ) - t; Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 120, 55, "Total de caracteres de name" ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 450, 55, AnsiString ( j ) ); Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 120, 75, "Tamanho do ponteiro name" ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 450, 75, AnsiString ( sizeof ( pt -> name ) ) ); Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 120, 95, "Tamanho da alocação estática para nomes" ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 450, 95, AnsiString ( sizeof ( pt -> nomes ) ) ); Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 120, 115, "Tamanho total consumido pela struct" ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 450, 115, AnsiString ( sizeof ( *pt ) ) ); strcpy ( pt -> nomes,"Devemos estudar linguagem de programação"); Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 120, 135, "Valor da variável nomes:" ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 120, 155, AnsiString ( pt -> nomes ) ); t = 0, j = 0; for ( i = 0; i < strlen ( pt -> nomes ); i++ ) { if ( pt -> nomes [ i ] == ' ' ) t++; } j = strlen ( pt -> nomes ) - t; Canvas -> Font -> Color = clBlue; Canvas -> TextOut ( 120, 175, "Total de caracteres de nomes" ); Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 450, 175, AnsiString ( j ) ); if ( x == true ) { exit ( 1 ); free ( pt ); free ( pt -> name ); } } void __fastcall TForm1::FormCreate ( TObject *Sender ) { Canvas -> Pen -> Width = 10; Canvas -> Pen -> Color = clYellow; Canvas -> Rectangle ( 05, 05, 595, 295 ); Canvas -> Font -> Size = 13; Canvas -> Font -> Name = "arial"; Canvas -> Font -> Style = TFontStyles() << fsBold << fsUnderline << fsItalic; Canvas -> Font -> Color = clRed; Canvas -> TextOut ( 140, 15, "OPERADOR SIZEOF E FUNÇÃO STRLEN" ); Inf_tam ( Sender ); Informe ( Sender ); } //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click ( TObject *Sender ) { Beep ( 1000, 500 ); x = true; } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- #ifndef Unit1H #define Unit1H //--------------------------------------------------------------------------- #include <System.Classes.hpp> #include <Vcl.Controls.hpp> #include <Vcl.StdCtrls.hpp> #include <Vcl.Forms.hpp> //--------------------------------------------------------------------------- class TForm1 : public TForm { __published: // IDE-managed Components TButton *Button1; void __fastcall Informe ( TObject *Sender ); void __fastcall Inf_tam ( TObject *Sender ); void __fastcall FormCreate(TObject *Sender); void __fastcall Button1Click(TObject *Sender); private: // User declarations public: // User declarations __fastcall TForm1(TComponent* Owner); }; //--------------------------------------------------------------------------- extern PACKAGE TForm1 *Form1; //--------------------------------------------------------------------------- #endif object Form1: TForm1 Left = 413 Top = 118 Caption = 'OPERADOR SIZEOF E FUN'#199#195'O STRLEN' ClientHeight = 300 ClientWidth = 600 Color = clBtnFace Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = 'Tahoma' Font.Style = [] OldCreateOrder = False Position = poDesigned OnPaint = FormCreate PixelsPerInch = 96 TextHeight = 13 object Button1: TButton Left = 32 Top = 259 Width = 49 Height = 25 Caption = 'Sair' TabOrder = 0 OnClick = Button1Click end end
  15. Se não me engano te passei um exemplo de um código meu mesmo para cadastro recentemente pelo facebook, Se eu estiver enganado queira me desculpar. De qualquer forma segue um exemplo criado por mim mesmo:

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

GRÁTIS: minicurso “Como ganhar dinheiro montando computadores”

Gabriel TorresGabriel Torres, fundador e editor executivo do Clube do Hardware, acaba de lançar um minicurso totalmente gratuito: "Como ganhar dinheiro montando computadores".

Você aprenderá sobre o quanto pode ganhar, como cobrar, como lidar com a concorrência, como se tornar um profissional altamente qualificado e muito mais!

Inscreva-se agora!