Ansi C

Aguardo ... adicionado 6 minutos depois Dei rápido pesquisada e vi que se trada de uma extensão do padrão. Tanto que só podemos usar quando aplicamos o macro: Que é bem sugestivo: __STDC: Padrão C _WANT: com _LIB: Bibliotecas _EXT1__: Extensiva 9899:201X

Mais o que você está dizendo não se aplica ao stdio.h, evidente que assim teríamos nos cabeçarios do arquivo stdio.h, aqui conta que a última modificação foi 2017. Esse arquivo é uma "SIGLA" para Standard Input and Output, e não consta essas funções nele, pelo menos não consigo enxergar nada do que você diz lá nesse arquivo de cabeçario. Poderia mostra um print da sua versão C11: Topo do arquivo onde consta o ano da versão, e o locais ondes os cabeçarios se encontram só para consta se aqui está faltando ou eu que não encontrei mesmo em minha versão. Por favor, poderia me dizer onde atualizar para mesma versão mais atual que 2017? Mesmo sendo padrão ou EXTENSÃO DO PADRÃO! Não se aplica a versão que estou usando 2017 como padrão. Eu não tinha que me preocupa com o identificadores causando conflitos, mesmo assim atualizo para que no futuro não venha até problemas: scanf_s para scanf_string para impedir futuros conflitos.

Correto! Quando a laço se encontrar com break é imediatamente interrompido. Só que o exemplo que você postou, especificamente com esses valores nos IFs, isso não vai acontecer: Melhor é você demostrar onde está querendo usar a interrupção com seu código definitivo para que possamos lhe ajudar melhor.

É sim, meu sistema é windows. adicionado 4 minutos depois Como esse compilador não é microsoft então essa função não é padrão.

Eu não uso esse compilador, eu uso o compilador baseado no Linux (Unix)! adicionado 1 minuto depois E também não uso o macro

Venho aos pouquinhos faz 4 anos (nunca passei dos básico "Hello C"), mais de fato mesmo foi nos últimos 6 meses que aprendi C/C++/C#. Não conte pra ninguém! Exatamente como dito por @isrnick !

Use: char * scanf_string (FILE * fluxo, int tamanho, char string[], char brk[]); /* * Funcao main : principal do programa */ int main (void){ char texto[300]; scanf_string (stdin, 300, texto, "\n"); return 0;} *Atualizado o identificador da função de scanf_s para scanf_string, para ficar de acordo com o Padrão C11.

Versão com stream: char * scanf_string(FILE * fluxo, int tamanho, char string[], char brk[]){ char fmt[120]; string[0] = '\0'; sprintf (fmt, "%%%d[^%s]", tamanho - 1, brk); fscanf (fluxo, fmt, string); for (char c = fgetc (fluxo); ('\n' != c)&&(c != EOF); c = fgetc ( fluxo )); return string;} Atualizado o identificador da função de scanf_s para scanf_string, para ficar de acordo com o Padrão C11

Use o Scanset : Vai captura o fluxo de caracteres até um condição seja satisfeita, para esse caso até que encontre nova-linha ('\n') podemos implementar um nova função scanf apenas para strings. char *scanf_string (int tamanho, char string[]){ char fmt[120]; string[0] = '\0'; sprintf (fmt, "%%%d[^\n]", tamanho - 1); scanf (fmt, string); for (char c = getchar (); ('\n' != c)&&(c != EOF); c = getchar ()); return string;} adicionado 9 minutos depois Atualizei para que possamos escolher o break: char * scanf_string (int tamanho, char string[], char brk[]){ char fmt[120]; string[0] = '\0'; sprintf (fmt, "%%%d[^%s]", tamanho - 1, brk); scanf (fmt, string); for (char c = getchar (); ('\n' != c)&&(c != EOF); c = getchar ()); return string;} Use assim: #include <stdio.h> char * scanf_s(int tamanho, char string[], char brk[]); /* * funcao main : principal do programa */ int main (void){ char seu_nome_completo[BUFSIZ]; printf ("$Entre com seu nome > "), scanf_s (BUFSIZ, seu_nome_completo, "\n"); printf (":Seu nome completo > %s\n\n", seu_nome_completo); return 0;} Ps.: Exitem muitas formar de se fazer isso, essa é que mais gosto Atualizado o identificador da função de scanf_s para scanf_string, para ficar de acordo com o Padrão C11

Nesse momento abriu-se o arquivo-texto no modo append: Os dados já serão gravados no fim do arquivo. Basta agora usar o comando de gravação que, suponho: Você ainda pode testar se foi gravado pelo retorna da função fputs: Errado estão o while e o fgets cout << "\n\nSeu nome é : " << word << "\n\n"; if (0 < fputs (word, file1)){ cout << "Arquivo recebeu nome!\n\n"; } else { cout << "Arquivo não recebeu nome!\n\n"; }

Os fatos: f == 4 → Verdadeiro; b ←100; b ← b + 1; b < 100 → Falso; São 3 ou + processos antes de finalizar o laço. for (int b = 0; b < 100; b++){ // Executa algo if (f == 4){ // Executa algo break;} // Se f != 4: Continua o ciclo for } break; Interrompe o laço imediatamente: O que economizará ~3 processos. Perguntas, dúvidas ou sugestões?

A função retorna. word[0] = toupper(word[0]);

A parte que tem a interrogação, ainda sim é acessível (leitura e gravação). #include <stdio.h> /* ~incluir: printf */ #include <limits.h> /* ~incluir: INT_MAX */ #define str(val) #val struct sttnumero { char caractere; int inteiro; }; /** funcao main ~ principal do programa */ int main (void){ struct sttnumero me = {0, INT_MAX}; * (int *) & me.caractere = INT_MAX; printf ("SizeOf %s: %u\n", str (me), sizeof me); printf ("Inteiro %s: %d\n", str (me.caractere), * (int *) & me.caractere); printf ("Inteiro %s: %d\n\n", str (me.inteiro), me.inteiro); printf ("Point %s: %u\n", str (me), & me); printf ("Point %s: %u\n", str (me.caractere), & me.caractere); printf ("Point %s: %u\n", str (me.inteiro), & me.inteiro); return 0; } Ps.: Bem previsível! adicionado 8 minutos depois Ou seja com conhecimento em ponteiro, e melhor declarar essa estrutura assim: struct sttnumero { char caractere; char inteiro[sizeof (int)]; }; E não se perderá memória! adicionado 16 minutos depois Dúvidas, ou sugestões?

E quem disse que não é!!! Essa parte da aritmética [i*sizeof(livros)] que conclui pela lógica, é um implementação internar: ponteiros são abstrações ou objetos implementados internamente. De fato todo ponteiro lista quando incrementado salta a quantidades de bytes que 1 dela só possui, semelhante a sua conclusão , isso é automático. adicionado 1 minuto depois Esse salto pode ser para frente ou para traz.

Discordo! typedef struct { char letra1; char letra2; char letra3; } Dados; Se testar para esse estrutura a resposta vai ser: 3 bytes, e não 4. adicionado 2 minutos depois O que implica a promoção é a presença de um tipo de 4 bytes. adicionado 4 minutos depois Não importa se ele está em cima, ou embaixo, ou no meio. Trata-se de uma otimização. adicionado 6 minutos depois Concordo!

As variáveis quando declaradas com static permanecem em local especial na memoria para esse tipo, ou classe de variável. Essa memória é definida no arranque do programa: quando clicamos em um programa e ele é carregado pelo sistema, esse por sua vez vai dedicar memória para esse tipo de variável, que permanecerá lá pelo tempo vital do programa. A função relatório retorna o local onde o "relatorio" foi salvo, retornando esse local especial. O Códio 6# não faz a mesma coisa, pois existe uma cópia entre dois locais de dados diferentes: o retorno da função relatorio gera um local, a variável na ponta dentro da função main gera outro novo local, os dois locais tem o mesmo tamanho, assim como um carimbo o "retorno de relatorio da uma carimbada" no local da memoria da variável em main e depois disso se destrói. Nesse (6#) caso foi um retorno envolvendo copia de dados, no outro com static foi um retorno envolvendo compartilhadamente de dados.

Essas coisas existem apenas em livros velhos do tempo do ANSI C que você encontra nas bibliotecas ou em artigos na internet. Meu caso foi na biblioteca mesmo, a maioria é inglês. Você pode pesquisar esses assunto, porém os melhores resultados vem de postes internacionais. Experientemente pesquisar: size of struct in C, ou sizeof dispensed more size struct Coisas assim vai lhe ajudar nas dúvidas, e se não nos conte que nós ajudaremos. adicionado 2 minutos depois Lembrei de um: A Bíblia do C\C++ - ótimo livro. adicionado 3 minutos depois Esse foi traduzido, acho que você pode encontra na internet em pdf!

Isso ocorre para otimizar o acesso a memória, e mais fácil calcular o tamanho do bloco de dados quando esse da salto de 1 em 1 ou de 2 em 2, ou de 4 em 4. adicionado 1 minuto depois No curso de Física

Essa promoção pode apenas ocorrer se houver um ou mais itens do tipo int, junto com número cuja a divisão por 4 de resto do tipo char. adicionado 1 minuto depois Exemplo: typedef struct { char letra1; int letra0; } Dados; O resultado vai ser 8.

Bem, provavelmente está promovendo o inteiro char para int

Ps.: Faça sizeof para cada tipo é constante seus tamanhos individuais.

Por padrão gcc compila em 32 bits independente do Windows 64, qual nome do seu compilador?

Para Windows 32bits essa estrutura tem: 9 bytes. char: 1 byte int: 4 bytes float: 4 bytes

Static permite que a variável seja lembrada e permaneça reservada na memória para uso até o fim do programa, o mesmos você poderia fazer sem definir static, porém correria riscos, pois a variável estaria sujeita a ser reutilizada com término da função relatorio, isso de fato é outra pergunta. Ps.: static é muito útil para implemento alloc: uma implementação local de controle de memória análogo a malloc só que no código, em geral definida no escopo global.

Isso é um erro lógico: pode ou não pode resultar em erros fatais: tipos de erros que finalizam os programas, e fazer ou não o inesperado. Quando atribui em vetores um tamanho sempre podemos ir além dele, pois a linguagem permite isso, entretanto, se acessar locais da memória já reservados vai resultar em erro em tempo de execução termina o programa e sair; esse é um erro bem comum no C. Contudo, existe um mínimo padrão de memória reservada para todo programa, quem reserva essa memória é o sistema operacional, pois bem é essa mídia chamada de Stack (pilha): ambiente na memória onde reside as variáveis temporárias, funções acionadas etc, você está livre para acessar, desde que, não ultrapasse seu limite, o limite se espante até o limite de memória sequência na heap: mídia da memória local do computador livre e progressiva em geral dinâmica, nos casos em que isso é implemento, porém definir um tamanho e acessar outro maior põem em risco toda lógica, o que significa dizer que vai funcionar: quando acessa um limite livre e reservado no arranque do programa, ou não vai funcionar: dependendo do quantitativo acessado extrapolou o limite ou alterou dados somente leitura, ou reservados. Entendeu?