kgin

@rafael carvalho melo Qual seria a sua duvida agora?

@felipe honorio Você tem duas opções, se caso você quiser "compilar e rodar" em um navegador você teria que usar as ferramentas do Emscripten para compilar para webassembly (Uma coisa que seria horrivelmente trabalhosa).

Agora se você quer um ambiente para rodar o programa e o seu programa não for muito carregado de coisas do sistema (mais especificamente o windows) você pode usar esse site https://www.onlinegdb.com/   

exemplo:Programa acerte o número.

@rafael carvalho melo Você tem que utilizar streams, eu não sei C++ mas aqui tem um link de como utilizar que parece ser fácil de entender.

Entrada/Saída com Streams

Exemplo de como seria.

#include <iostream>
#include <string>

using namespace std;

int main() {
    string aluno;
    int idade = 0;
    cout << "Digite o nome do aluno\n";
    cin >> aluno;

    cout << "Digite a idade do aluno\n";
    cin >> idade;

    cout << "Nome do aluno:" << aluno << "\n";
    cout << "Idade do aluno:" << idade << "\n";
    return 0;
}

@rafael carvalho melo Mas você está fazendo em qual linguagem de programação?

@PT_Richard_Assis Qual sistema operacional você está usando?

É normal algumas detecções de vírus nos arquivos compilados com a configuração padrão do codeblocks, mas essas suas aí estão meio estranhas.

De uma olhada no meu.

Pode ser que o seu sistema esteja com algum tipo de malware.

É como o @mauro_b explicou, a maneira digamos assim "correta" seria assim.

#include <stdio.h>
#include <stdlib.h>



void
aloca(float **p, int tam);

void
apaga(float **p);


int main(void)
{
        int cont;
        float *numeros;
        aloca(&numeros, 10);

        if (numeros == NULL) {
                return(1);              /* Erro! */
        }

        for (cont = 0; cont < 10; cont++) {
                numeros[cont] = cont+1;
        }

        for (cont = 0; cont < 10; cont++) {
                printf("\n%.2f", numeros[cont]);
        }
        getchar();

        apaga(&numeros);
        return(0);
}


void
aloca(float **p, int tam)
{
        *p = malloc(sizeof(*p)*tam);
}

void
apaga(float **p)
{
        if (*p != NULL) {
                free(*p);
        }

        *p = NULL;
}

aprenda a usar o gdb (ou o debug disponível do seu compilador) que ele será uma mão na roda nesse tipo de situação.

1 minuto atrás, RobertoGB disse:

@kgin  Você está usando conceitos que a pessoa nem deve ter visto ainda.

Me restringir ao máximo em só usar elementos da propria linguagem C, são conceitos que no geral você ver nas primeiras paginas de um livro de C.

A solução seria você colocar a números aleatórios com a função rand().

a linha 8 e 9 estão erradas, observe bem aqui

8 minutos atrás, julia0906 disse:

Considere o programa para gerar 100 números inteiros aleatórios no intervalo de 0 até 9.

O vetor só vai de 0 a 9, é cadê os outros 90 números?

9 minutos atrás, julia0906 disse:

8. int i, f[10] = {0}; 9. for(i = 1; i <= 100; i++)

@catherineprokhorov Não é possível  você fazer um shift right (rolar a direita) em vetores, você teria que implementar isso.

#include <stdio.h>

#define T_STR 256

enum direcao
{
    ESQUERDA,
    DIREITA
};

void
rolaString(char *str, enum direcao direcao, unsigned short quantidade);

int main(void)
{
    char str[256] = "Imposto e roubo!";

    rolaString(str, DIREITA, 7);

    printf("\n%s", str);
    getchar();
    return(0);
}

void
rolaString(char *str, enum direcao direcao, unsigned short quantidade)
{
    char tmp[T_STR];
    unsigned short tamanho_str, cont, aux;

    for (tamanho_str = 0; str[tamanho_str]; tamanho_str++);

    switch (direcao) {
        case ESQUERDA:
            break;
        case DIREITA:
            if (quantidade < tamanho_str) {
                /* Copia a primeira parte */
                for (cont = tamanho_str-quantidade, aux = 0; str[cont]; cont++, aux++) {
                    tmp[aux] = str[cont];
                }

                /* Copia a segunda parte */
                for (cont = 0; cont < tamanho_str-quantidade; cont++, aux++) {
                    tmp[aux] = str[cont];
                }

                tmp[tamanho_str] = '\0';
                for (cont = 0; tmp[cont]; cont++) {
                    str[cont] = tmp[cont];
                }
            }
            break;
    }
}

Eu fiz esse exemplo de como seria para a rolar a direita.

Uma maneira seria assim.

#include <stdio.h>

int main(void)
{
    char str[256] = "Imposto", final[256];
    sprintf(final, "%s e roubo!", str);

    printf("\n%s", final);
    getchar();
    return(0);
}

Mas se for um trabalho de faculdade creio eu que o certo seria manipular as letras no vetor.

Eu fiz um reduzido para ajudar em um dever escolar aqui, não sei se está tudo correto, mas eu acho que seria uma boa base para você.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define Q_ESTADOS 5
#define T_STR 256

const char *sigla_estados[Q_ESTADOS] = {"DF", "PB", "RJ", "RS", "PA"};

const unsigned short 
distancia_estados[Q_ESTADOS][Q_ESTADOS] = {{0, 2245, 1148, 2027, 2110},
                                           {2245, 0, 2448, 3889, 2161},
                                           {1148, 2448, 0, 1553, 3250},
                                           {2027, 3884, 1553, 0, 3852},
                                           {2120, 2161, 3250, 3852,0}};

int main(int argc, char *argv[])
{
    char ds1[T_STR], ds2[T_STR];
    int sair, cont, est1, est2;
    do {
        int estados_encontrados = 0;
        sair = 0;
        printf("\nDigite uma capital:\t");
        fgets(ds1, T_STR, stdin);
        printf("\nDigite outra capital:\t");
        fgets(ds1, T_STR, stdin);
        /* Retira o newline das strings */
        ds1[strlen(ds1)-1] = '\0';
        ds2[strlen(ds2)-1] = '\0';

        /* Passa a string para mauiscula */
        for (cont = 0; cont < strlen(ds1); cont++) {
            if (ds1[cont] > 97) {
                ds1[cont] -= 32;
            }
        }
        for (cont = 0; cont < strlen(ds2); cont++) {
            if (ds2[cont] > 97) {
                ds2[cont] -= 32;
            }
        }

        /* acha o estado */
        est1 = 0;
        for (cont = 0; cont < Q_ESTADOS; cont++) {
            if (strcmp(sigla_estados[cont], ds1) == 0) {
                est1 = cont;
                estados_encontrados = 1;
                break;
            }
        }

        est2 = 0;
        for (cont = 0; cont < Q_ESTADOS; cont++) {
            if (strcmp(sigla_estados[cont], ds2) == 0) {
                est2 = cont;
                estados_encontrados = 1;
                break;
            }
        }

        if (estados_encontrados) {
            printf("\nA distancia entre %s e %s e:\t%hu",
                   sigla_estados[est1], sigla_estados[est2],
                   distancia_estados[est1][est2]);
        } else {
            printf("\nEstados nao encontrados!");
        }

        if (estados_encontrados) {
            char opcao;
            printf("\nProcurar outro estado?\nS\\N:\t");
            scanf("%c%*c", &opcao);
            if (opcao == 's' || opcao == 'S')
                sair = 1;
        } else {
            char opcao;
            printf("\nEstados disponiveis.\n");
            for (cont = 0; cont < Q_ESTADOS; cont++) {
                printf("%s,", sigla_estados[cont]);
            }
            printf("\nTentar novamente com algum estado difirente?\nS\\N:\t");
            scanf("%c%*c", &opcao);
            if (opcao == 's' || opcao == 'S')
                sair = 1;
        }
    } while (sair);
    return(0);
}

Tirei os dados do livro teláris 6 serie 2015, pagina 70.

@Joel Martins Não se pode compara strings dessa maneira em C, a "melhor maneira" seria assim.

#include <stdio.h>
#include <string.h>

#define T_STR 256

int
contaOcorrencia(char *str, char *oc);

int main(int argv, char *argc[])
{
    char str[T_STR], palavra[T_STR];
    if (argv > 1) {
        strcpy(str, argc[1]);
        strcpy(palavra, argc[2]);
    } else {
        printf("\nDigite uma palavra:\t");
        fgets(str, T_STR, stdin);
        printf("\nDigite a ocorrencia na palavra:\t");
        fgets(palavra, T_STR, stdin);
        /* Retira o newline */
        str[strlen(str)-1] = palavra[strlen(palavra)-1] = '\0';
    }

    printf("\nQuantidade de ocorrencias da palavra %s na palavra %s:%i",
            palavra, str, contaOcorrencia(str, palavra));
            
    getchar();      /* pausa o programa */
    return(0);
}

int
contaOcorrencia(char *str, char *oc)
{
    unsigned short 
    t_str = strlen(str),
    t_oc = strlen(oc)-1,
    ocorrencias = 0;

    char tmp[T_STR];

    if (t_str > 0 && t_oc > 0) {
        unsigned short cont = 0;
        do {
            if (cont < t_str) {
                strcpy(tmp, &str[cont]);
                tmp[t_oc+1] = '\0';
                if (strcmp(tmp, oc) == 0) {
                    cont+=t_oc;
                    ocorrencias++;
                } else {
                    cont++;
                }
            }
        } while (cont < t_str);
        return(ocorrencias);
    }
    return(0);
}

@paulo luz magalhaes Me desculpe eu acabei não prestando atenção no seu programa, eu fiz um de exemplo para você.

#include <stdio.h>

#define T_PALAVRA 256

int
checaPalindromo(char *p);
/*
 * Devolve 1 se for palindromo e 0 se não for.
 */

int main(int argc, char *argv[])
{
    char palavra[T_PALAVRA];
    int cont;
    /* Checa se foi passada alguma palavra para o programa */
    if (argc > 1) {
        /* Mostra as palavras */
        for (cont = 1; cont < argc; cont++) {
            printf("\n%s", argv[cont]);

            /* Checa palindromo */
            if (checaPalindromo(argv[cont])) {
                printf(":E palindromo!");
            } else {
                printf(":Nao e palindromo");
            }
        }
    } else {
        printf("\nDigite uma palavra:");
        fgets(palavra, T_PALAVRA, stdin);
        /* Retira o newline da palavra */
        for (cont = 0; palavra[cont]; cont++);

        palavra[cont-1] = '\0';
        
        /* Checa palindromo */
        if (checaPalindromo(palavra)) {
            printf(":E palindromo!");
        } else {
            printf(":Nao e palindromo");
        }
    }
    getchar();      /* Faz uma pausa */
    return(0);
}

int
checaPalindromo(char *p)
{
    char str[256];
    int q_caracteres_palavra, q_caracteres_iguais = 0, cont, aux;
    /* Conta a quantidade de caracteres e passa a palavra para mauiscula para outro vetor */
    for (q_caracteres_palavra = 0; p[q_caracteres_palavra]; q_caracteres_palavra++) {
        if (p[q_caracteres_palavra] > 97) {
            /* Passa a letra para mauiscula e copia para outro vetor */
            str[q_caracteres_palavra] = p[q_caracteres_palavra]+32;
        }
        str[q_caracteres_palavra] = p[q_caracteres_palavra];
    }
    /* Coloca o indicador \0 na string */
    str[q_caracteres_palavra] = '\0';
    
    /* Checa palindromo */
    aux = q_caracteres_palavra-1;
    for (cont = 0; str[cont]; cont++) {
        if (str[cont] == str[aux]) {
            q_caracteres_iguais++;
        }
        aux--;
    }

    if (q_caracteres_iguais == q_caracteres_palavra) {
        return(1);
    }
    return(0);
}

11 minutos atrás, paulo luz magalhaes disse:

Debuguei o meu programa corrigido e o seu tambem. Ao digitar a palavra "ovo" ou a frase "saudavel leva duas", ambos os programas acusam que não são palíndromos. Estou tentando quebrar a cabeça e ver como corrijo...

mas qual seria o propósito do seu programa?

@paulo luz magalhaes Creio eu que o que você está tentando fazer é isso.

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

int main(void)
{
    char nome[40];
    int i,x,acertos; 

    printf("Entre com uma palavra ");
    scanf("%s%*c", nome);

    /*for (i=strlen(nome)-1,x=0; i>=0,x<strlen(nome); i--,x++)
    {
        if (nome[x] == nome)
        {
            acertos++;
        }
    }
 

    if(acertos==strlen(nome))
    {
        printf("A palavra e um palindromo");
    }
    else
    {
        printf("A palavra nao e um palindromo");
    }*/

    /* Passa a palavra para mauiscula */
    for (i = 0; nome[i] != 0; i++)
    {
        nome[i] = toupper(nome[i]);     /* toupper() e da biblioteca ctype.h */
    }
    
    /* strcmp() e da biblioteca string.h */
    if (strcmp(nome, "PALINDROMO") == 0)        /* Compara as duas palavras */
    {
        printf("\nA palavra e palindromo.");
    }
    else
    {
        printf("\nA palavra nao e palindromo.");
    }
    
    getchar();      /* Faz uma pausa */
    return 0;
}

Use espaços ao invés de tabs para indentar, tente também copiar do jeito que eu deixei a indentação.

Do modo que eu fiz fica mais fácil de visualizar o código.

1 hora atrás, linco_araujo12 disse:

-totalmente de jogos.

Quero ideias de programas para se desenvolver nessas linguagens a cima no título.

Aí vem a pergunta, que tipo de programas você já desenvolveu em C (lembrando que C não tem nada a ver com C++)?

Eu recomendaria você fazer um programa igual ao dir (do windows) ou ls (do linux) e um programa simples que mostra todas as pastas e arquivos da pasta atual.

@paulo luz magalhaes Não sei se isso é um "dever de casa", mas o seu código não tem uma função main fora que o C e  sensível à caixa das letras (case sensitive).

então eu acho que não posso ajudar além disso.

@devair1010 Você tem que trocar a extensão do arquivo para C, é depois ir nas configurações do visual studio e trocar a codificação do arquivo para utf-8 com BOOM.

adicione essa linha ao programa que talvez resolva o problema.

_setmode(_fileno(stdout), _O_U16TEXT);

fonte:Microsoft documentation _setmode. 

Eu daria uma resposta mais elaborada sobre o problema, mas isso já é questão do compilador.

@Épsilon para usar a acentuação gráfica a maneira mais simples é utilizar a biblioteca wchar.

exemplo:

#include <stdio.h>
#include <locale.h>
#include <wchar.h>

int main(void)
{
    wchar_t str[256] = L"Olá como vai!";
    setlocale(LC_ALL, "");
    wprintf(L"\n%ls", str);
    wprintf(L"\nDigite seu primeiro nome:");
    wscanf(L"%ls%*c", str);
    wprintf(L"\n%ls", str);
    getchar();
    return(0);
}

Mas se você estiver iniciando nos seus estudos de C eu recomendo só esquecer isso por hora.

58 minutos atrás, Luccas Fernando disse:

fflush: se o argumento for NULL, ela limpa todos os buffers abertos, mas ela funciona somente para a stdout, então como isso é possível?

O 'f' em fflush e de arquivo (file) isso vem do antigo unix em que tudo era um arquivo, então em poucas palavras ela funciona em qualquer arquivo aberto.

1 hora atrás, Luccas Fernando disse:

_flushall: esta não precisa de argumentos, e limpa todos os buffers abertos, mas qual a consequência disso? O que de tão ruim pode acontecer em um contexto no qual desenvolvo um programa simples, de iniciante?

Isso depende de quão perto você está do kernel, um programa rodando em user space (espaço de usuário) não afetaria muito o sistema, mas um programa rodando em kernel space (espaço do kernel) travaria a maquina ao fazer um flush em todos os buffers.

No ponto de vista da linguagem C um flush em todos os buffers só é útil em caso de falha grave onde um processo secundário trava, é o primário fica sendo responsável por limpar toda a bagunça do secundário (isso só seria aceitável no user space).

todas as outras funções como _flushall e _fflush_nolock são funções do windows, fugindo do padrão do C, isso que dizer que não são portáveis.

@aparecidamariavilela Eu não sei C++, mas um exemplo em C talvez elucide o funcionamento para ti.

#include <stdio.h>

#define TAMANHO 256 /* Tamanho da string */

int main(void)
{
    char str[TAMANHO];
    /* Pega a string */
    printf("\nDigite uma frase:\t");
    fgets(str, TAMANHO, stdin);

    putchar('\n');      /* Salta uma linha */
    for (int cont = 0; str[cont]; cont++) {
        /* Checa se não é um espaço */
        if (str[cont] != ' ') {
            putchar(str[cont]);
        }
    }
    getchar();
    return(0);
}

A ideia básica do algoritmo seria você pegar caractere por caractere, é checar se o caractere não é um espaço antes de colocar no outro arquivo.