C++ Programação no visual studio.

[Welberts Dhemes]

#include <stdio.h>

#include <stdlib.h>

 

int main(void) {

    //     Exercício 4:

    // Replique o exercício

    // 3. Porém, agora, declare um ponteiro para a estrutura de dados heterogênea.

    // No momento da leitura dos dados e da impressão na tela, use o ponteiro

    // para buscar o conteúdo dos campos. Imprima na tela também o seu RU na tela.

    struct aluno {

            char *nome;

            int RU;

    };

   

    // define struct aluno para usá-lo como "aluno"

    typedef struct aluno aluno;

   

    // inicializando aluno como a1

    aluno a1;

   

    // ponteiro apontando para a1

    aluno *a = &a1;

   

    // alocando espaço de memória para a1.nome

    a->nome = malloc(sizeof(char) * 64);

   

    // capturando dados do usuário

    printf("Digite seu nome: ");

    scanf("%s", a->nome);

    printf("Digite seu RU: ");

    scanf("%d", a->RU);

   

    // exibindo dados para o usuário

    printf("Nome do aluno =====> %s\nRU do aluno ====> %d\n", a->nome, a->RU);

   

    return 0;

}

 

 

Estou tento problemas com esse código, podem me ajudar.

[allanxd]

Faltou o & no último scanf.

[Welberts Dhemes]

1 hora atrás, allanxd disse:

Faltou o & no último scanf.

Obrigado amigo, adicionei mais ainda não funciona.

[allanxd]

@Welberts Dhemes , poste o código modificado.

[Welberts Dhemes]

10 minutos atrás, allanxd disse:

@Welberts Dhemes , poste o código modificado.

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

int main(void) {
    //     Exercício 4:
    // Replique o exercício
    // 3. Porém, agora, declare um ponteiro para a estrutura de dados heterogênea.
    // No momento da leitura dos dados e da impressão na tela, use o ponteiro
    // para buscar o conteúdo dos campos. Imprima na tela também o seu RU na tela.
    struct aluno {
        char *nome;
        int RU;
    };

    // define struct aluno para usá-lo como "aluno"
    typedef struct aluno aluno;

    // inicializando aluno como a1
    aluno a1;

    // ponteiro apontando para a1
    aluno *a = &a1;

    // alocando espaço de memória para a1.nome
    a->nome = malloc(sizeof(char) * 64);

    // capturando dados do usuário
    printf("Digite seu nome: ");
    scanf("%s", a->nome);
    printf("Digite seu RU: ");
    scanf("%d", &a->RU);

    // exibindo dados para o usuário
    printf("Nome do aluno =====> %s\nRU do aluno ====> %d\n", a->nome, a->RU);

    return 0;
}

[allanxd]

@Welberts Dhemes Dá algum erro do compilador? Testei aqui e está funcionando corretamente. Lembrando que uso o compilador MinGW que vem junto com o Code::Blocks, mas você está usando o do Visual Studio. Não sei se é esse compilador que está "estranho".

 

Além do mais, que tipo de entrada está utilizando para testar o seu código? Tente trocar o scanf("%s", a->nome); por fgets(a->nome, 64, stdin);

[Welberts Dhemes]

9 minutos atrás, allanxd disse:

@Welberts Dhemes Dá algum erro do compilador? Testei aqui e está funcionando corretamente. Lembrando que uso o compilador MinGW que vem junto com o Code::Blocks, mas você está usando o do Visual Studio. Não sei se é esse compilador que está "estranho".

Sim, o visual as vezes muda alguma coisa, dão 3 erros e são esses:

Gravidade    Código    Descrição    Projeto    Arquivo    Linha    Estado de Supressão
Erro (ativo)    E0513    um valor do tipo "void *" não pode ser atribuído para uma entidade do tipo "char *"    Project12    C:\Users\w_elb\source\repos\Project12\Project12\Origem.cpp    25    
 

Gravidade    Código    Descrição    Projeto    Arquivo    Linha    Estado de Supressão
Erro    C2440    '=': não é possível converter de 'void *' para 'char *'    Project12    c:\users\w_elb\source\repos\project12\project12\origem.cpp    25    
 

Gravidade    Código    Descrição    Projeto    Arquivo    Linha    Estado de Supressão
Aviso    C4473    'scanf_s' : não há argumentos suficientes transmitidos para a cadeia de caracteres de formato    Project12    c:\users\w_elb\source\repos\project12\project12\origem.cpp    29    
 

Mudei o scanf para scan_f e reduzir um erro.

 

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

int main(void) {
    //     Exercício 4:
    // Replique o exercício
    // 3. Porém, agora, declare um ponteiro para a estrutura de dados heterogênea.
    // No momento da leitura dos dados e da impressão na tela, use o ponteiro
    // para buscar o conteúdo dos campos. Imprima na tela também o seu RU na tela.
    struct aluno {
        char *nome;
        int RU;
    };

    // define struct aluno para usá-lo como "aluno"
    typedef struct aluno aluno;

    // inicializando aluno como a1
    aluno a1;

    // ponteiro apontando para a1
    aluno *a = &a1;

    // alocando espaço de memória para a1.nome
    a->nome = malloc(sizeof(char) * 64);

    // capturando dados do usuário
    printf("Digite seu nome: ");
    scanf_s("%s", a->nome);
    printf("Digite seu RU: ");
    scanf_s("%d", &a->RU);

    // exibindo dados para o usuário
    printf("Nome do aluno =====> %s\nRU do aluno ====> %d\n", a->nome, a->RU);

    return 0;
}

[allanxd]

@Welberts Dhemes Tente a->nome = (char*)malloc(sizeof(char) * 64); e veja o meu comentário acima de novo pois acrescentei mais informação.

[Welberts Dhemes]

15 minutos atrás, allanxd disse:

@Welberts Dhemes Tente a->nome = (char*)malloc(sizeof(char) * 64); e veja o meu comentário acima de novo pois acrescentei mais informação.

Resolvido amigo, obrigado, fiz as alterações e deram resultado.

[Heliton Potter]

Para a mesma questão estou com problema neste código, preciso crias ponteiros heterogenios.

 

 #include <stdio.h>
#include <stdlib.h>
int main()//chamando a função  
{
    printf("****Dados de entrada****\n\n");//imprimindo na tela  
    struct dados_do_aluno {//criando uma struct  
        char nome[30];// declarando um vetor na struct  
        int ru;// declarando uma variavel na struct  
    }; struct dados_do_aluno aluno;
    printf("Digite o nome do aluno :");// imprimindo na tela  
    fflush(stdin); // limpando os buffer de memoria  
    fgets(aluno.nome, 30, stdin);//alocando os dados de entrada na struct aluno no vetor nome  
    printf("\n Digite o RU :");// imprimindo na tela
    scanf_s("%d", &aluno.ru);//alocando os dados de entrada na variavel ru  
    printf("\n");
    printf("\n***Dados de saida***");// imprimindo os dados de saida  
    printf("\nNome do aluno:%s", aluno.nome);
    printf("\nRU do aluno:%d", aluno.ru);
    printf("\n\n");
    system("pause");
    return 0;
}

[arfneto]

Olá!

 

Não entendi:

 

• o que é uma estrutura de dados heterogênea
• o que é um ponteiro heterogêneo
• E onde entra a programação no Visual Studio, o título do tópico
• Está estudando C ou C++? Digitou o tópico como sendo C++ mas postou um programa em C na prática. C++ por exemplo não usa mais funções como malloc() e struct evoluiu para class, por exemplo. Isso como está escrito é compatível mas não é C++.

 

De todo modo de uma olhada no exemplo abaixo e talvez ajude a entender. E escreva com mais detalhes sobre a dúvida atual

struct Aluno
{
    char*   nome;
    int     RU;
};

Em especial para quem está começando, acho que fica mais claro pra entender que ao declarar nome e nome é um ponteiro para char declarar assim como está acima

char*    nome

ao invés de 

char    *nome;

Outra convenção que pode ajudar é declarar as estruturas com uma maiúscula no início assim ao ler o programa você já identifica alguns erros comuns.
O typedef aluno é uma boa ideia mas usar o mesmo nome não é. e usar depois também não.

 

Prefira:

typedef struct Aluno
{
    char*   nome;
    int     RU;
};

Aluno    a1;
aluno*    pAluno;

Talvez concorde que escrever assim

Aluno a1, *a2, outroAluno, *outroPonteiroParaALuno

não é tão claro quanto

Aluno a1;
Aluno*    a2;
Aluno    outroAluno;
Aluno*  outroPonteiroParaAluno;

Outra convenção comum que pode ajudar quem está aprendendo: declarar ponteiros para estruturas começando por p e tendo o nome da estrutura depois, como

Aluno*    pAluno1;

malloc() é assim

void*    malloc(size_t size);

Então ela devolve o que talvez seja o que você chama de ponteiro heterogêneo, mas não acho que a palavra se aplique a isso: um ponteiro para (void). Isso é algo bem besta: como malloc() não sabe para que tipo de variável vai alocar memória --- ou quanto vai alocar --- não é surpresa que devolva um ponteiro para (void). Mas tanto faz porque você imediatamente acaba escrevendo algo assim

int* pParaUnsInt = (int *) malloc(300 * sizeof(int));

e resolvendo as duas dúvidas: quantos usando sizeof() e apontando para que através do (int *) que se chama cast.

De volta ao seu programa, todos os parâmetros de scanf() são endereços.
Então scanf("%s", pAluno->nome); está ok porque nome é (char *) mas
scanf("%d", pAluno->RU);
não porque RU é (int)
Então precisa do operador & para passar o endereço de RU

O exemplo abaixo mostra isso na tela:

Nome do aluno, usando a struct: [TESTE: o que tem no nome do aluno]
Nome do aluno, usando o ponteiro para struct: [TESTE: o que tem no nome do aluno]
Digite seu nome: forum
Digite seu RU: 123456789
Nome:  =====> [forum]
RU:    ====> 123456789
Nome:  =====> [forum]
RU:    ====> 123456789

O programa

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include "string.h"


int main(int argc, char** argv)
{
    typedef struct
    {
        char* nome;
        int     RU;
    }    Aluno;

    Aluno  aluno1;
    Aluno* pAluno;
    Aluno* pAluno1 = &aluno1;    // tambem esta certo

    char* umNome = "TESTE: o que tem no nome do aluno";

    pAluno = &aluno1;
    // alocando espaço de memória para aluno1.nome com 64 bytes
    aluno1.nome = malloc(sizeof(char) * 64);
    // liberando o espaco
    free(aluno1.nome);
    // alocando de novo usando o ponteiro
    pAluno1->nome = malloc(sizeof(char) * 64);
    memcpy(pAluno->nome, umNome, strlen(umNome)+1);
    //
    // agora mostra para ver se está certo
    printf("Nome do aluno, usando a struct: [%s]\n", aluno1.nome);
    printf("Nome do aluno, usando o ponteiro para struct: [%s]\n", pAluno->nome);

    // capturando dados do usuário

    printf("Digite seu nome: ");
    scanf("%s", aluno1.nome);

    printf("Digite seu RU: ");
    scanf("%d", &aluno1.RU);

    // exibindo dados para o usuário usando struct
    printf("Nome:  =====> [%s]\n", aluno1.nome);
    printf("RU:    ====> %d\n", aluno1.RU);

    // exibindo dados para o usuário usando o ponteiro
    printf("Nome:  =====> [%s]\n", pAluno->nome);
    printf("RU:    ====> %d\n", pAluno->RU);

    return 0;

}    // end main()

E pode ver as duas maneiras de acessar a estrutura.