Módulo 9
--------------------------------------- ---------- #include //para system () {# include ... C ++ códigos ...} -------------------- ----------------------------- deve ser alterado para: ---------------- --------------------------------- #include //usar C ++ wrapper para chamar funções C a partir de programas em C ++ ... #include using namespace std; ... {C ++ códigos ...} ---------------------------------------- --------- Em VC ++ /VC ++ .Net o iostream.h (cabeçalho com .h) não é mais válido. Deve ser cabeçalho C ++, de modo que cumprir com a norma.
Em mais velho Borland C ++ compilador esta ainda funciona, mas não adequada mais ... e por padrão C /C ++ a portabilidade não deve ser problema ou melhor você ler Module23 em https://www.tenouk.com/Module23.html chegar a grande figura ... Para os códigos C, eles ainda códigos C: o) ================================= ======================================== ========== ================================================== ============= //Abertura e fechamento de arquivo exemplo #include #include //SUCCESS = 0, falha = 1 usando enum enumeração {SUCCESS, FALHA}; int main (void) {FILE * fptr; //o nome do arquivo é tkk1103.
txt e localizado //na mesma pasta como o programa de char filename [] = "tkk1103.txt"; //definir o valor reval a 0 int reval = SUCESSO; //arquivo de abertura de teste para a leitura, se falhar ... if ((fptr = fopen (filename, "r")) == null) {printf (, filename "Não é possível abrir% s. \\ n"); reval = FALHA; //redefinir reval 1} //se for bem sucedida fazer ... else {printf ("Abrindo o arquivo% s com sucesso \\ n", filename); //o programa exibirá o endereço onde //o ponteiro aponta para arquivo .. printf ("O valor de fptr: 0x% p \\ n", fptr); printf ("\\ n ....
processamento de arquivos deve ser feito aqui .... \\ n"); printf ("\\ nReady para fechar o arquivo% s. \\ n", filename); //fechar o fluxo de arquivo ... se (fclose (fptr) == 0) printf ("Fechando o arquivo% s com sucesso \\ n", filename); } //... Para Borland pode remover o seguinte pausa ea biblioteca, //stdlib.h para o sistema de outros compiladores ("pause"); retornar reval; } ------------------------------ Testtwo.txt ---------------- ---------------------------------- ABERTURA, leitura, escrita e fecho de ficheiros -------- ----------------------------------- Lima do teste.
Este arquivo chamado testtwo.txt. Depois de abrir arquivos para leitura e escrita, sem erro, o conteúdo deste arquivo (testtwo.txt) será lido e saída (gravação) para o outro arquivo chamado testone.txt e saída padrão (/console tela) caractere por caractere !!! --- Feliz aprendendo FOLKS !!! ---- ------------------------------------- -------------------------------------------------- ----- //Ler e escrever um carácter de cada vez #include #include //tipo de dados enumerado, SUCCESS = 0, falha = 1 enum {SUCCESS, FALHA}; //função protótipo para ler e escrever ...
CharReadWrite void (FILE * fin, FILE * fout); int main () {//declarar dois ponteiros de arquivo ... FILE * fptr1, * fptr2; //definir o nome de dois arquivos ... Char filename1 [] = "testone.txt"; carbonizar filename2 [] = "testtwo.txt"; int reval = SUCESSO; //testar a filename1 abertura para escrever .... //se falhar .... if ((fptr1 = fopen (filename1, "w")) == null) {printf ("Problem, não é possível abrir% s. \\ n ", filename1); reval = FALHA; } //Se abrindo filename1 para a escrita for bem sucedida, //teste para a abertura para a leitura filename2, se falhar ...
else if ((fptr2 = fopen (filename2, "r")) == null) {printf ("Problem, Não é possível abrir% s \\ n ", filename2.); reval = FALHA; } //Se abertura bem sucedida para a leitura de filename2 //e escrita para filename1 ... else {//chamada de função para leitura e escrita ... CharReadWrite (fptr2, fptr1); //fechar ambos os arquivos ... if (fclose (fptr1) == 0) printf ("% s \\ estreita com sucesso n", filename1); if (fclose (fptr2) == 0) printf ("% s \\ estreita com sucesso n", filename2); } //Para Borland se compilado usando seu IDE ...
sistema ("pause"); retornar reval; } //Leia definição da função de gravação CharReadWrite void (FILE * fin, FILE * fout) {int c; //se o fim do arquivo é alcançado, do ... while ((c = fgetc (fin)) = EOF!) {//escrita para um ... fputc (c, fout) arquivo; //exibe na tela ... putchar (c); } Printf ("\\ n"); } ------------------------------------ Testfour.txt ---------- --------------------------- ABERTURA, ler, escrever uma linha de caracteres -------------- -------------------------------------- Este é o arquivo testfour.txt.
O conteúdo deste arquivo será linha por linha de caracteres lidos até não mais linha de caráter encontrados. Em seguida, será a saída para a tela e também serão copiados para o arquivo testhree.txt. Verifique o conteúdo do arquivo testhree.txt ... --------------------------------------- ------------- ------------------TENHA UM BOM DIA--------------- ---- ---------------------------------------------- --------------------------------------- //Ler e escrever uma linha de cada vez # incluir enum {#include SUCESSO, FALHA, MAX_LEN = 100}; //função protótipo para leitura e escrita por linha ...
LineReadWrite void (FILE * fin, ARQUIVO fout *); int main (void) {FILE * fptr1, * fptr2; //arquivo testhree.txt está localizado na raiz, c: //você pode colocar este arquivo em qualquer local desde //que você forneça o caminho completo, mesmo para testfour.txt carvão filename1 [] = "c: \\\\ testhree. TXT"; Char filename2 [] = "c: \\\\ testfour.txt"; Char reval = SUCESSO; //test abertura testhree.txt arquivo para gravação, se falhar ... if ((fptr1 = fopen (filename1, "w")) == null) {printf ("Problem, não pode abrir% s para escrita. \\ n" , filename1); reval = FALHA; } //Test abertura testfour.
txt arquivo para leitura, se falhar ... else if ((fptr2 = fopen (filename2, "r")) == null) {printf ("Problem, não pode abrir% s para leitura. \\ n ", filename2); reval = FALHA; } //Se abrindo escrita fro e ler bem sucedido, fazer ... else {//chamada de função para ler e escrever, linha por linha ... LineReadWrite (fptr2, fptr1); //fechar os dois arquivos de fluxo ... if (fclose (fptr1) == 0) printf ("% s fechou com sucesso. \\ n", filename1); if (fclose (fptr2) == 0) printf ("fechada com sucesso \\ n% s.
", filename2); } //Para o sistema Borland screenshot ("pause"); retornar reval; } //Definição de função para a linha de leitura, gravação ... LineReadWrite void (FILE * fin, FILE * fout) {//variável local ... lustre de char [MAX_LEN]; while (! fgets (lustre, MAX_LEN, fin) = null) {//gravação para arquivar ... fputs (lustre, fout); //escrita para a tela ... printf ("% s", lustre); }} ----------------------------------------- Testsix.
txt ---- ------------------------------------------ ABERTURA, leitura e escrita de um bloco de Este é DADOS ----------------------------------------------- arquivar testsix.txt. O seu conteúdo será lido e, em seguida, saída para a tela /console e copiado para testfive.txt arquivo. A leitura e escrita com base em bloco de dados. Pode ser este método é mais rápido em comparação com leitura /escrita pelo personagem, pela linha .....
----------------------------- ------------------ ------------------FIM------------- ------------- ------------------------------------- -------------------------------------------------- ----------- //Ler e escrever um bloco de cada # include #include tempo //declarar tipo de dados de enumeração, você vai aprender neste //em outro módulo ... enum {SUCCESS, FALHA, MAX_LEN = 80}; //função protótipo para a leitura e escrita bloco vazio BlockReadWrite (FILE * fin, ARQUIVO fout *); //função protótipo para mensagens de erro ...
int ErrorMsg (char * str); int main (void) {FILE * fptr1, * fptr2; //definir os nomes de arquivos ... //o local de arquivos está em c: \\ Temp carvão filename1 [] = "c: \\\\ \\\\ Temp testfive.txt"; Char filename2 [] = "c: \\\\ \\\\ Temp testsix.txt"; int reval = SUCESSO; //test abertura testfive.txt arquivo para gravação, se falhar ... if ((fptr1 = fopen (filename1, "w")) == null) {reval = ErrorMsg (filename1); } //Test abertura testsix.txt arquivo para leitura, se falhar ...
else if ((fptr2 = fopen (filename2, "r")) == null) {reval = ErrorMsg (filename2); } //Se a abertura de arquivos para escrita e leitura for bem sucedido, fazer ... else {//função de chamada para leitura e escrita BlockReadWrite (fptr2, fptr1); //fechar ambos os fluxos arquivos ... if (fclose (fptr1) == 0) printf ("\\ n êxito fechado% s", filename1); if (fclose (fptr2) == 0) printf ("\\ n êxito fechado% s", filename2); } Printf ("\\ n"); //para Borland ...
sistema ("pausa"); retornar reval; } //Definição de função para leitura de bloco, escrever vazio BlockReadWrite (FILE * fin, FILE * fout) {int num; Char lustre [MAX_LEN + 1]; //enquanto não terminar de arquivo para arquivo de entrada, do ... while {//lendo ... num = fread (lustre, sizeof (char), MAX_LEN, fin) (feof (fin)!); //anexa um aficionado por caractere nulo [num * sizeof (char)] = '\\ 0'; printf ("% s", lustre); //escrever ... fwrite (lustre, sizeof (char), num, fout); }} //Definição da função de mensagem de erro int ErrorMsg (char * str) {//exibe a mensagem de erro ...
printf ("Problem, não é possível abrir% s. \\ N", str); retornar FALHA; } -----------------------------------------tesseven.txt------------------------------------------------------ ESTA É A primeira linha do texto, tesseven.txt arquivo Esta é a segunda linha de texto, tesseven.txt arquivo Esta é a linha TERCEIRO DE TEXTO, tesseven.txt arquivo Esta é a linha QUARTO DE TEXTO, tesseven.
txt arquivo - -------------------------------------------------- -------------------------------------------- //acesso aleatório a um arquivo # include #include enum {SUCCESS, FALHA, MAX_LEN = 120}; //protótipos de função, procure o indicador de posição de arquivo vazio PtrSeek (FILE * fptr); //função protótipo, diga o indicador de posição de arquivo ... long PtrTell (FILE * fptr); //função protótipo ler e escreve ... anular DataRead (FILE * fptr); int ErrorMsg (char * str); int main (void) {FILE * fptr; Char filename [] = "c: \\\\ \\\\ Temp tesseven.
txt"; int reval = SUCESSO; //se houver algum erro ao abrir arquivo para leitura ... if ((fptr = fopen (filename, "r")) == null) {reval = ErrorMsg (filename); } //Se a abertura for bem sucedida ... else {//PtrSeek () chamada de função ... PtrSeek (fptr); //fechar o fluxo de arquivo ... se (fclose (fptr) == 0) printf ("% s fechou com sucesso. \\ n", filename); } //...
Para Borland sistema ("pause"); retornar reval; } //PtrSeek () definição de função vazio PtrSeek (FILE * fptr) {offset1 longo, offset2, offset3, offset4; offset1 = PtrTell (fptr); DataRead (fptr); offset2 = PtrTell (fptr); DataRead (fptr); offset3 = PtrTell (fptr); DataRead (fptr); offset4 = PtrTell (fptr); DataRead (fptr); printf ("\\ nReread o tesseven.txt, em ordem aleatória: \\ n"); //reler a segunda linha do fseek tesseven.txt (fptr, offset2, SEEK_SET); DataRead (fptr); //reler a primeira linha do fseek tesseven.
txt (fptr, offset1, SEEK_SET); DataRead (fptr); //reler a quarta linha do fseek tesseven.txt (fptr, offset4, SEEK_SET); DataRead (fptr); //reler a terceira linha do fseek tesseven.txt (fptr, offset3, SEEK_SET); DataRead (fptr); } //PtrTell () definição de função longo PtrTell (FILE * fptr) {long reval; //dizer a posição fptr ... reval = ftell (fptr); printf ("O fptr está em% ld \\ n", reval); retornar reval; } //DataRead () definição de função vazio DataRead (FILE * fptr) {char lustre [MAX_LEN]; //linha de texto de leitura na posição fptr ... fgets (lustre, MAX_LEN, fptr); //e exibir o texto ..
. printf ("->% s \\ n", lustre); } //Erro definição da função mensagem int ErrorMsg (char * str) {//exibe esta mensagem de erro ... printf ("Problem, não é possível abrir% s. \\ N", str); retornar FALHA; } ------------------------------------------------- ------------------------------------------- //leitura, escrita, retrocesso e dados binários #include #include enum {SUCCESS, FALHA, MAX_NUM = 5}; //funções protótipo ... DataWrite void (FILE * fout); anular DataRead (FILE * fin); int ErrorMsg (char * str); int main (void) {FILE * fptr; //arquivos binários ...
tipo de char filename [] = "c: \\\\ \\\\ Temp teseight.bin"; int reval = SUCESSO; //teste para criar, abrir o arquivo binário para a escrita ... if ((fptr = fopen (filename, "wb +")) == null) {reval = ErrorMsg (filename); } Else {//Escreve dados em um arquivo teseight.bin DataWrite (fptr); //repor o indicador de posição de arquivo ... rewind (fptr); //ler dados ... DataRead (fptr); //fechar o fluxo de arquivo ...
se (fclose (fptr) == 0) printf ("\\ n êxito fechado% s", filename); } //Para o sistema de Borland ("pause"); retornar reval; } //DataWrite () definição de função vazio DataWrite (FILE * fout) {int i; duplo lustre [MAX_NUM] = {145,23, 589,69, 122,12, 253,21, 987,234}; printf ("O tamanho do lustre:% d bytes \\ n", sizeof (lustre)); for (i = 0; i {printf ("% 5.
2f \\ n", lustre [i]); fwrite (& lustre [i], sizeof (double), 1, fout);}} //DataRead () definição de função anular DataRead (FILE * fin) {int i; duplas x; printf ("\\ nReread do arquivo binário: \\ n"); for (i = 0; i {fread (& x, sizeof (double), (size_t) 1 , fin); printf ("% 5.2f \\ n", X);}} //ErrorMsg () definição da função int ErrorMsg (char * str) {printf ("Não é possível abrir% s. \\ n", str); retorno FALHA;} --------------------------------------- testcal.
txt ----- ---------------------------------- 23 12 33 10 4 6 44 31 7 50 ------ -------------------------------------------------- --------------------------------- /* Programa C para calcular a média de uma lista de números. * //* calcular o total de um arquivo, a saída do médio * //* em outro arquivo * /# include /* para exit () * /#include int main (void) {int valor, o total = 0, count = 0; /* fileptrIn e fileptrOut são variáveis do tipo (FILE *) * /FILE * fileptrIn, * fileptrOut; carvão filenameIn [100], filenameOut [100]; printf ("Por favor, indique um nome de arquivo de entrada (uso caminho se necessário): \\ n" ); scanf ("% s", filenameIn); printf ("Por favor, indique um nome de arquivo de saída (uso caminho se necessário): \\ n"); scanf ("% s", filenameOut); /* arquivos abertos para leitura, "r" e escrito, "w" * /if ((fileptrIn = fopen (filenameIn, "r")) == null) {printf ("Erro ao abrir% s para leitura.
\\ n" , filenameIn); saída
(1); } Else printf ("Abrir% s para leitura é OK. \\ N", filenameIn); if ((fileptrOut = fopen (filenameOut, "w")) == null) {printf ("Erro ao abrir% s para escrita. \\ n", filenameOut); saída
(1); } Else printf ("Abrir% s para escrita é OK. \\ N", filenameOut); /* fscanf * /printf ("\\ nCalculate total ... \\ n"); while (EOF = fscanf (fileptrIn, "% i", e valor)!) {total de + = valor; ++ contar; } /* fim do loop while * //* Escreva o valor médio para o arquivo * //* * fprintf /printf ("Calcule a média ... \\ n \\ n.
"); fprintf (fileptrOut, "Média de% i números =% f \\ n", conta, /(duplo) contagem total); printf ("% i média de números =% f \\ n \\ n", conta, /(duplo) contagem total); printf ("Verifique também o seu conteúdo% s arquivo \\ n", filenameOut); if (fclose (fileptrIn) == 0) printf ("% s \\ fechados com sucesso n", filenameIn); if (fclose (fileptrOut) == 0) printf ("% s \\ fechados com sucesso n", filenameOut); retornar 0; } ------------------------------------------------- -------------------------------------------- //Redirecionando um fluxo padrão #include #include enum {SUCCESS, FALHA, STR_NUM = 6}; vazio StrPrint (char ** str); int ErrorMsg (char * str); int main (void) {//declarar e definir um ponteiro para cadeia .
.. char * str [STR_NUM] = {"Redirecionando um fluxo padrão para o arquivo de texto.", "Estes 5 linhas de texto será redirecionado", " tantas coisas que você pode fazer se você entender o conceito "," idéia fundamental - tentar um "," -------------- FEITO ---------- ---------------- "}; Char filename [] = "c: \\\\ \\\\ Temp testnine.txt"; int reval = SUCESSO; StrPrint (str); //criar o arquivo se não existir e aberto para escrever ... //se existir, descarte o conteúdo anterior ... if (fReopen (filename, "w", stdout) == null) {reval = ErrorMsg (filename); } Else {//chamar StrPrint function () ...
StrPrint (str); //fechar a saída padrão ... fclose (stdout); } Retornar reval; } //StrPrint () definição de função vazio StrPrint (char ** str) {int i; for (i = 0; i //a norma de tela de saída /console ... printf ("% s \\ n", str [i]); system ("pause");} //ErrorMsg () função definição int ErrorMsg (char * str) {printf ("Problem, não é possível abrir% s. \\ n", str); retornar FALHA;} ---------------------- -------------------------------------------------- -------------- //Demonstrar a #include remove () função #include void main () {//declarar uma matriz para armazenar nome de arquivo ...
Char filename [80]; printf ("Digite o nome do arquivo a ser excluído:"); fica (filename); //verifica qualquer erro ... se (remover (filename) == 0) printf (". O arquivo% s foi deletada \\ n", filename ); outra coisa fprintf (stderr, "Erro ao excluir arquivo% s. \\ n", filename); system ("pause");} --------------------- -------------------------------------------------- ---------------- //Usando renomear () para alterar um nome de arquivo # include #include void main () {char oldname [80], newname [80]; printf ("Digite filename atual: "); gets (oldname); printf (" Digite um novo nome para o arquivo: "); gets (newname); if (renomear (oldname, newname) == 0) {printf ("% s tem sido renomear% s \\ n ", oldname, newname).
; } Else {fprintf (stderr, ". Ocorreu um erro de renomear% s \\ n", oldname); } Sistema ("pausa"); } ------------------------------------------------- ------------------------------------------- //Copiando um arquivo # include #include int file_copy (char * oldname, char newname *); main () {fonte vazio char [80], o destino [80]; //obter o printf nomes de origem e destino ("arquivo de origem \\ nDigite:"); gets (de origem); printf ("arquivo de destino \\ nDigite:"); gets (destino); if (file_copy (origem, destino) == 0) puts ("Operação de cópia de sucesso"); mais fprintf (stderr, "Erro durante a operação de cópia"); sistema ("pausa"); } Int file_copy (char * oldname, char * newname) {FILE * dobra, * fnew; int C; //Abre o arquivo de origem para a leitura em modo binário if ((dobra = fopen (oldname, "rb")) == null) return -1; //Abre o arquivo de destino para escrever no modo binário (se (= fnew fopen (newname, "wb")) == null) {fclose (dobrar); retornar -1; } //Leia um byte de cada vez a partir da fonte, se o fim do arquivo //não foi atingido, escrever o byte para o destino while
(1) {c = fgetc (dobrar); if (! feof (dobrar)) fputc (c, fnew); outro break; } Fclose (fnew); fclose (dobrar); retornar 0; } ------------------------------- Testfour.
txt --------------- --------------------- ------------------ LINUX LOR! -------- ------------ ---------------- FEDORA 3, gcc xxx ----------------- --- ABERTURA, ler, escrever uma linha de caracteres -------------------------------------- -------------- Este é o arquivo testfour.txt. O conteúdo deste arquivo será linha por linha de caracteres lidos até não mais linha de caráter encontrados. Em seguida, será a saída para a tela e também serão copiados para o arquivo testhree.txt. Verifique o conteúdo do arquivo testhree.txt ...
--------------------------------------- ------------- ------------------TENHA UM BOM DIA--------------- ---- ---------------------------------------------- --------------------------------- /*************** readline .c ************ /* Ler e escrever uma linha de cada vez * /#include #include enum {SUCCESS, FALHA, MAX_LEN = 100}; /* função protótipo para leitura e escrita por linha ... * /LineReadWrite void (FILE * fin, FILE * fout); int main (void) {FILE * fptr1, * fptr2; /* arquivo testhree.txt está localizado na pasta atual.
você pode colocar este arquivo em qualquer local, desde que você forneça o caminho completo, mesmo para testfour.txt * /char filename1 [] = "testhree.txt"; carbonizar filename2 [] = "testfour.txt"; Char reval = SUCESSO; /* Teste de abertura testhree.txt arquivo para gravação, se falhar ... * /if ((fptr1 = fopen (filename1, "w")) == null) {printf ("Problem, não pode abrir% s para escrita. \\ n ", filename1); reval = FALHA; } /* Teste de abertura testfour.txt arquivo para leitura, se falhar ...
* /else if ((fptr2 = fopen (filename2, "r")) == null) {printf ("Problem, não pode abrir% s para leitura . \\ n ", filename2); reval = FALHA; } /* Se abrindo escrita fro e ler bem sucedido, fazer ... * /else {/* chamada de função para ler e escrever, linha por linha ... * /LineReadWrite (fptr2, fptr1); /* fechar os dois arquivos de fluxo ... * /if (fclose (fptr1) == 0) printf ("% s fechou com sucesso. \\ n", filename1); if (fclose (fptr2) == 0) printf ("fechada com sucesso \\ n% s.
", filename2); } Retornar reval; } /* Definição de função para a linha de leitura, gravação * /LineReadWrite void (FILE * fin, FILE * fout) {/* variável local ... * /char lustre [MAX_LEN.]; while (! fgets (lustre, MAX_LEN, fin) = null) {/* gravação para o arquivo ... * /fputs (lustre, fout); /* escrita para a tela ... * /printf ("% s", lustre); }} ------------------------------------------------ ---------------------------------------------- ////////////rwbinary.
c////////////////FEDORA 3, gcc xxx ///////leitura, escrita, rebobinar e dados binários #include enum {SUCCESS, FALHA, MAX_NUM = 5}; //funções protótipo ... DataWrite void (FILE * fout); anular DataRead (FILE * fin); int ErrorMsg (char * str); int main (void) {FILE * fptr; //arquivos do tipo binários ... filename char [] = "/testo1/testo2/teseight.bin"; int reval = SUCESSO; //teste para criar, abrir o arquivo binário para a escrita ... if ((fptr = fopen (filename, "wb +")) == null) {reval = ErrorMsg (filename); } Else {//Escreve dados em um arquivo teseight.
bin DataWrite (fptr); //repor o indicador de posição de arquivo ... rewind (fptr); //ler dados ... DataRead (fptr); //fechar o fluxo de arquivo ... se (fclose (fptr) == 0) printf ("\\ n êxito fechado% s", filename); } Retornar reval; } //DataWrite () definição de função vazio DataWrite (FILE * fout) {int i; duplo lustre [MAX_NUM] = {145,23, 589,69, 122,12, 253,21, 987,234}; printf ("O tamanho do lustre:% d bytes \\ n", sizeof (lustre)); for (i = 0; i {printf ("% 5.
2f \\ n", lustre [i]); fwrite (& lustre [i], sizeof (double), 1, fout);}} //DataRead () definição de função anular DataRead (FILE * fin) {int i; duplas x; printf ("\\ nReread do arquivo binário: \\ n"); for (i = 0; i {fread (& x, sizeof (double), (size_t) 1 , fin); printf ("% 5.2f \\ n", X);}} //ErrorMsg () definição da função int ErrorMsg (char * str) {printf ("Não é possível abrir% s. \\ n", str); retorno FALHOU; } ====================================================================================================;>;>.h>.h>.h>.h>.h>.h>.h>.h>.h>;>.h>.h>.h>.h>;>;>.h>.h>.h>.h>.h>.h>.h>.h>.h>.h>.
h>.h>.h>.h>