Random number when allocation struct integer (int) in C - c

I'm allocating dynamically the amount of ram that I will need for my program. It is working fine until I came across this problem. This is when I type the content that is going to be inside of my one item that is inside the struct which is referred to as an Integer if I type more than 10 number for example (12345678912) it will send me back, a completely different number.
Here is my code:
#include <stdio.h>
#include <stdlib.h>
struct cadastro
{
char email[50];
char nome[20];
int idade;
int telefone;
};
int main()
{
int quantidade_cadastros;
int decisao = 1;
printf("\nQuantos cadastros deseja realizar?\n");
printf("Quantidade: ");
scanf("%d", &quantidade_cadastros);
getchar();
//Definindo a quantidade de cadastros que podem ser realizados no struct e o nome que sera usado para chamar o struct
struct cadastro *cad;
cad = NULL;
cad = malloc(quantidade_cadastros * sizeof(struct cadastro));
for (int i = 0; i < quantidade_cadastros; i++)
{
printf("\nDigite o NOME da pessoa que sera inserida no indice %d: ", i);
fgets(cad[i].nome, 20, stdin);
printf("Digite o EMAIL da pessoa que sera inserida no indice %d: ", i);
fgets(cad[i].email, 50, stdin);
printf("Digite a IDADE da pessoa que sera inserida no indice %d: ", i);
scanf("%d", &cad[i].idade);
getchar();
printf("Digite o TELEFONE da pessoa que sera inserida no indice %d: ", i);
scanf("%d", &cad[i].telefone);
getchar();
}
for (int i = 0; i < quantidade_cadastros; i++)
{
printf("\nNOME: %s", cad[i].nome);
printf("EMAIL: %s", cad[i].email);
printf("IDADE: %d", cad[i].idade);
printf("\nTELEFONE: %d", cad[i].telefone);
printf("\n");
}
printf("\n");
free(cad);
}
Here is the input I entered:
Quantos cadastros deseja realizar?
Quantidade: 2
Digite o NOME da pessoa que sera inserida no indice 0: Test1
Digite o EMAIL da pessoa que sera inserida no indice 0: Email1
Digite a IDADE da pessoa que sera inserida no indice 0: 19
Digite o TELEFONE da pessoa que sera inserida no indice 0: 1234567891
Digite o NOME da pessoa que sera inserida no indice 1: Test2
Digite o EMAIL da pessoa que sera inserida no indice 1: Email2
Digite a IDADE da pessoa que sera inserida no indice 1: 18
Digite o TELEFONE da pessoa que sera inserida no indice 1: 12345678912
NOME: Test1
EMAIL: Email1
IDADE: 19
TELEFONE: 1234567891
NOME: Test2
EMAIL: Email2
IDADE: 18
TELEFONE: -539222976

You are running into an int overflow. The second 'phone number' you typed in is larger than an int can store, and you are not verifying the reading. The scanf probably failed, and stored nothing in the int - which means there is still random bits in its memory area, as you never cleared it. The printf then prints those random information.
You should always verify that scanf was successful - it will return the number of successfully assigned fields, here 1. So you should use `if (scanf(...) != 1) { /handle error/ }, instead of ignoring it.

Related

Calculation the number of white pieces on the masterMind game in C

Forgive me for any writing mistakes english is not my first languange.
I'm coding the MasterMind (if you are not familiar with the game you can consult its rules in here https://magisterrex.files.wordpress.com/2014/07/mastermindrules.pdf) game in C to take part in a larger project, i pretty much finish it but i'm stuck in the function when the program calculates the number of white pieces; a white piece is basically when the player guess's the right colour in the wrong spot.
My code for that function doesn't work if the board (generate at random by the computer) as two pieces of the same color and the player guesses one of them in the wrong place.
The code is in portuguese (my native tongue) i hope that doesn't prevent my from getting help.
Thanks for yout help
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define STRING_MAXIMO 10
void gerarTabuleiro(int nivel, char (*tabuleiro)[STRING_MAXIMO])
{
//Declaração e inicialização de variaveis locais
//Arrays de onde serão escolhidas aleatoriamente as cores de acordo com o nivel escolhido
char coresNivel1[6][STRING_MAXIMO] = {"vermelho", "verde", "azul", "amarelo", "rosa", "ciano"};
char coresNivel2[7][STRING_MAXIMO] = {"vermelho", "verde", "azul", "amarelo", "rosa", "ciano", "castanho"};
char coresNivel3[8][STRING_MAXIMO] = {"vermelho", "verde", "azul", "amarelo", "rosa", "ciano", "castanho", "roxo"};
int index;//Variavel que controlar todos os ciclos desta função
srand(time(NULL));//Iremos alimentar o tabueleiro com uma uma nova combinação de todas as vezes (rand irá se basear na data e hora do sistema)
if(nivel == 1){//Nivel 1 selecionado
for(index = 0; index != nivel + 3; index++)//Para cada posição do tabuleiro (4 peças)
strcpy(tabuleiro[index], coresNivel1[rand() % 6]);//Será escolhido aleatoriamente uma cor do array pre-determinado
}
else if(nivel == 2){//Nivel 2 selecionado
for(index = 0; index != nivel + 3; index++)//Para cada posição do tabuleiro (5 peças)
strcpy(tabuleiro[index], coresNivel2[rand() % 7]);//Será escolhido aleatoriamente uma cor do array pre-determinado
}
else if(nivel == 3){//Nivel 3 selecionado
for(index = 0; index != nivel + 3; index++)//Para cada posição do tabuleiro (6 peças)
strcpy(tabuleiro[index], coresNivel3[rand() % 8]);//Será escolhido aleatoriamente uma cor do array pre-determinado
}
}
int calculaPretas(int nivel, char (*tabuleiro)[STRING_MAXIMO], char (*palpite)[STRING_MAXIMO])
{
//Declaração e incialização de variaveis locais
int index;//Variaveis que controlarão os ciclos para iterar sobre o tabuleiro e o palpite do jogador
int nDp = 0;//Variavel auxiliar que ira controlar o numero de acertos na posição correta do utilizador
for(index = 0; index != nivel + 3; index++){/*Iremos simultaneamente comparar o primeiro palpite do utilizador com a primeira posição do tabuleiro,
o segundo palpite com a segunda posição e assim sucessivamente*/
if(strcmp(palpite[index], tabuleiro[index]) == 0)//Caso a cor seja correta
nDp++;//Iremos incrementar o numero de peças acertadas em uma unidade
}
return nDp;
}
int calculaBrancas(int nivel, char (*tabuleiro)[STRING_MAXIMO], char (*palpite)[STRING_MAXIMO])
{
//Declaração e incialização de variaveis locais
int indexT, indexP;//Variaveis que controlarão os ciclos para iterar sobre o tabuleiro e o palpite do jogador (indexT iterara sobre o tabuleiro e indexP iterara sobre o palpite)
int nDp = 0;//Variavel auxiliar que ira controlar o numero de acertos na posição errada do utilizador
int contabilizado[nivel+3];//Vetor que irá armazenar se um elemento do palpite já foi contabilizado como peça branca
//Inicialização do array a 0, pois uma posição será colocada a 1 sempre que essa peça branca já tenha sido contabilizada
for(int index = 0; index != nivel + 3; index++)
contabilizado[index] = 0;
for(indexP = 0; indexP != nivel + 3; indexP++){//Ciclo que ira iterar sobre o palpite fornecido pelo jogador
for(indexT = 0; indexT != nivel + 3; indexT++){//Ciclo que ira iterar sobre as peças do tabuleiro
if((strcmp(palpite[indexP], tabuleiro[indexT]) == 0) && indexP != indexT && !contabilizado[indexP]){//Iremos verificar se a cor existe no tabuleiro mas esta colocada na posição errada
nDp++;//Incremento do numero de peças brancas no tabuleiro
contabilizado[indexP] = 1;//Incremento da peça contabilizada ao array
}
}
}
return nDp;
}
int main(int argc, char *argv)
{
//Declaração e inicialização de variaveis locais (automaticas)
int nivel;//Variavel que ira permitir ao utilizador selecionar o numero de peças no tabuleiro e as cores usadas
int numeroDecasas;//Varivel que guardará o numero de casas de acordo com o nivel escolhido
int index;//Variavel que controlar todos os ciclos desta função
//Explicação das regras do jogo
printf("#############################################################################################################\n");
printf("# O objectivo do Mastermind é descobrir uma combinação de cores determinada aleatoriamente pelo computador. #\n");
printf("# Para tal e necessario que escolha o nivel de jogo adequado #\n");
printf("# Nivel 1 -> 4 casas e 6 cores possiveis #\n");
printf("# Nivel 2 -> 5 casas e 7 cores possiveis #\n");
printf("# Nivel 3 -> 6 casas e 8 cores possiveis #\n");
printf("# Escolha o nivel pretendido #\n");
scanf("%i", &nivel);
printf("# Nivel %i selecionado #\n", nivel);
printf("#############################################################################################################\n\n\n");
//Declaração condicional do tamanho do tabuleiro de acordo com o nivel escolhido
char tabuleiro[nivel + 3][STRING_MAXIMO];/*Declaramos um array de n posições (nº casas é sempre o nivel + 3 exemplo nivel 1 -> 4 casas;
nivel 3 -> 6 casas) e com o tamanho maximo de uma string (caracteres numa cor)*/
char palpite[nivel + 3][STRING_MAXIMO];/*Array que guardará os palpites do jogador*/
gerarTabuleiro(nivel, tabuleiro);
/*Teste*/
//Impressão do tabuleiro - retirar em versão final
printf("| ");
for(index = 0; index != nivel + 3; index++){
printf("%s | ", tabuleiro[index]);
}
printf("\n\n");
/*Fim de teste*/
//Declaração e inicialização de variaveis locais
int novoPalpite;//Variavel que ira permitir ao utilizador desistir do jogo ou continuar a dar palpites (1 -> continuar || 2 -> desistir)
int tentativas = 0;//Variavel que irá contar o numero de palpites que o jogador necessitou para ganhar
int numeroDeBrancas = 0, numeroDePretas = 0;//Variaveis que informarão o jogador de quão perto se encontra de ganhar
do{
//Pedido ao utilziador do seu palpite
printf("# Insira o seu palpite #\n");
for(index = 0; index != nivel + 3; index++){//Para cada casa do nivel atual
printf("# Casa %i\t", index + 1);//Sera informada a posição atual da casa a preencher
scanf("%s", palpite[index]);//E pedido ao utilziador que escolha uma cor para a preencher
}
tentativas++;
numeroDePretas = calculaPretas(nivel, tabuleiro, palpite);
numeroDeBrancas = calculaBrancas(nivel, tabuleiro, palpite);
printf("###########################################\n");
printf("# Numero de peças pretas: %i #\n", numeroDePretas);
printf("#Numero de peças brancas: %i #\n", numeroDeBrancas);
printf("###########################################\n");
if(numeroDePretas == nivel + 3){
printf("###########################################\n");
printf("# Necessitou de %i tentativas para ganhar #\n", tentativas);
printf("# TABULEIRO #\n# ");
for(index = 0; index != nivel + 3; index++)
printf("%s # ", tabuleiro[index]);
printf("\n###########################################\n");
break;
}
printf("# Deseja introduzir um novo palpite #\n");
printf("# 1. Novo palpite #\n");
printf("# 2. Desistir #\n");
scanf("%i", &novoPalpite);
if(novoPalpite == 2){
printf("# Desistiu do jogo #\n");
printf("# Tabuleiro #\n ");
printf("| ");
for(index = 0; index != nivel + 3; index++)
printf("%s | ", tabuleiro[index]);
printf("\n\n");
}
}while(novoPalpite == 1);//Peças pretas (cor e posição correta)
return 0;
}
I make one cycle controlled by indexP iterate on the guess from the player and another cycle iterating on the board it self, if the string is the same in any position execept in the same postion of both (definition of black piece) and i verify if the piece as already conteded as a white piece (i think this is the part that isn't workin but im not sure)
OT: This code is unreadable with its often duplicated comments, even if one knows the language (which I do not.)
Here is your first function re-written:
void gerarTabuleiro(int nivel, char tabuleiro[][] ) {
char coresNivel[] = {
"vermelho", "verde", "azul", "amarelo", "rosa", "ciano", "castanho", "roxo"
};
srand(time(NULL));
for( int i = 0; i < nivel + 3; i++ )
strcpy( tabuleiro[ i ], coresNivel[ rand() % (nivel + 5)] );
}
Instead of copy/paste, strive to write crisp, concise code that achieves the objective.

strange int returned from a function

im facing one strange scenario when the output of my function return a ENORMOUS int (4225528), when im trying to sum simple values in a var and return that var to store in a struct.
Whats hapenning ? I tried a simple pointer func that i saw here, didnt work, heres my code, anyone has idea how to solve this ?
The function is "int cadastrarPedido(int Cad);"
Executable : https://repl.it/#thzmendes/UnwrittenHorizontalStructs
Here is where i call and the func
#include <stdio.h>
int cadastroPedido(int Cad);
int main(void) {
printf("Voce selecionou a opcao 4 - Cadastrar Pedido\n");
int Cad;
int vlr_T=0;
printf("\nDigite numero do cadastro: ");
scanf("%d",&Cad);
vlr_T = cadastroPedido(Cad);
printf("\n Valor total : %d",&vlr_T);
return 0;
}
int cadastroPedido(int Cad){
int Option;
int OpcaoPedido;
int valor=0;
if(Cad>0)
{
do
{
printf("\nEscolha o seu pedido: ");
printf("\n1- Pizza de Calabresa -50 reais");
printf("\n2- Pizza de Frango - 40 reais");
printf("\n2- Pizza de Mussarela - 30 reais");
printf("\n2- Coca Cola- 10 reais");
printf("\n2- Guarana- 10 reais");
scanf("%d", &OpcaoPedido);
if(OpcaoPedido == 1)
{
printf("\nPressione 1 para continuar pedindo ou 2 para volar ao menu principal: ");
valor +=50;
scanf("%d", &Option);
}
else
if(OpcaoPedido == 2)
{
printf("\nPressione 1 para continuar pedindo ou 2 para volar ao menu principal: ");
scanf("%d", &Option);
valor +=40;
}
else
if(OpcaoPedido == 3)
{
printf("\nPressione 1 para continuar pedindo ou 2 para volar ao menu principal: ");
scanf("%d", &Option);
valor +=30;
}
else
if(OpcaoPedido == 4)
{
printf("\nPressione 1 para continuar pedindo ou 2 para volar ao menu principal: ");
scanf("%d", &Option);
valor +=10;
}
else
if(OpcaoPedido == 5)
{
printf("\nPressione 1 para continuar pedindo ou 2 para volar ao menu principal: ");
scanf("%d", &Option);
valor +=10;
}
}while(Option == 1);
}
return valor;
}
I've slapped your code a little bit. This code snippet was enough to reproduce your "bug".
#include <stdio.h>
int cadastroPedido(int Cad);
int main(void) {
int valor = cadastroPedido(1);
printf("%d",valor);
return 0;
}
int cadastroPedido(int Cad){
int Option;
int OpcaoPedido;
int valor;
if(1==Cad)
{
do
{
printf("\nEscolha o seu pedido: ");
printf("\n1- Pizza de Calabresa -50 reais");
printf("\n2- Pizza de Frango - 40 reais");
scanf("%d", &OpcaoPedido);
if(OpcaoPedido == 1)
{
printf("\nPressione 1 para continuar pedindo ou 2 para volar ao menu principal: ");
valor +=50;
scanf("%d", &Option);
}
else
if(OpcaoPedido == 2)
{
printf("\nPressione 1 para continuar pedindo ou 2 para volar ao menu principal: ");
scanf("%d", &Option);
valor +=40;
}
}while(Option == 1);
}
return valor;
}
You'll see that the local variable of cadastroPedido valor is uninitialized when the function is called. This means that the program will pick a position in memory. Due to RAM shenanigans, that position in memory may have a random value already in it.
You can avoid this by explicitly declaring it like int value = 0, so you will always know the starting value of that variable and so that you aren't at the mercy of preexisting memory states.
If you don't initialize variables when you declare them in C, you're at risk of tripping into these inconsistencies, specially during += operations.

Error on Result

int idade, salario,maior, menor, media, somasalario =0, i=0;
char sexo;
char estadoc;
do {
printf("Insira a sua idade:");
scanf("%d", &idade);
if (idade > maior) {
maior = idade;
}
if (idade < menor) {
menor = idade;
}
printf("Insira o seu salario:");
scanf("%d", &salario);
somasalario += salario;
printf("Introduza o seu sexo:");
scanf("%c", &sexo);
printf("Introduza o seu estado civil:");
scanf("%c", &estadoc);
printf("Salario menor que 0!");
}while(idade !=-1);
printf("idade maior: %d", maior);
}
it's my code, and when i run the program, the printf stay like this:
"Insira o seu salario:500
Introduza o seu sexo:Introduza o seu estado civil:
"
someone can help me please?
I have annotated various corrections to your program. It now works, although it does not seem to do anything very useful. In fact it always tells me "Salario menor que 0!"
#include <stdio.h>
#include <limits.h> // added header
int main(void)
{
int idade=0, salario=0, maior=INT_MIN, menor=INT_MAX, somasalario=0;
char sexo=' ', estadoc=' '; // initialised variables
do {
printf("Insira a sua idade: ");
if (scanf("%d", &idade) != 1)
return 1; // input error
if (idade > maior) {
maior = idade;
}
if (idade < menor) {
menor = idade;
}
printf("Insira o seu salario: ");
if (scanf("%d", &salario) != 1)
return 1; // input error
somasalario += salario;
printf("Introduza o seu sexo: ");
if (scanf(" %c", &sexo) != 1) // added space to clean input
return 1; // input error
printf("Introduza o seu estado civil: ");
if (scanf(" %c", &estadoc) != 1) // added space to clean input
return 1; // input error
printf("Salario menor que 0!\n"); // added newline
} while(idade !=-1);
printf("idade maior: %d\n", maior); // added newline
return 0;
}

Unable to delete a determinate position in the struct, the data persist

First at all english its not my first language i will try my best.
Hello guys, I have a problem i'm trying to delete a determinate position of the struct, so instead of deleting the info inside by modifying the string with strcpy or just setting the int or float to 0 i want to erase the data in the struct by changing the position with the next one so 1.2.3.4.5 will be 1.2<-3.4.5 and stay this way 1.2.3.4, problem is after 1h trying to make it works there are some problems, first: if there's only one student after the program ask me for the id to erase, the new id seems to be a random number or like garbage data, so i guess the position changed but the data inside of this id persist.
Example:
id: 1
name: john
lastname: smith
score1: 2
score2: 5
score3: 6
After the function ask me for the id to be erased:
id: 425262
name: john
lastname: smith
score1: 2
score2: 5
score3: 6
the second issue is, if i insert some students, and the program ask for the id to be erased, all id numbers changes to that id i just insert instead of deleting the id target.
Heres the full code:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
struct alumnos{
int id;
char alumno[10];
char apellido[15];
float nota1;
float nota2;
float nota3;
};
int insertar_notas(struct alumnos notas[20],int n,int *id_alumno);
void mostrar_notas(struct alumnos notas[20],int n);
void buscar_alumno(struct alumnos notas[20],int n);
void cambiar_notas(struct alumnos notas[20],int n);
void eliminar_alumno(struct alumnos notas[20],int n);
int main (void){
int menu = 0, n = 0, id_alumno = 1;
struct alumnos notas[20];
puts("\n<><><>Bienvenido al recuento de notas de la escuela<><><>\n");
puts("\nQue deseas hacer?\n");
while (menu != 6){
puts("\n1)Insertas las notas de un alumno\n2)Ver todas las notas\n3)Ver las notas de un alumno\n4)Modificar notas\n5)Eliminar datos del alumno\n6)Salir\n");
scanf("%d", &menu);
switch(menu){
case 1:
n=insertar_notas(notas,n,&id_alumno);
break;
case 2:
mostrar_notas(notas,n);
break;
case 3:
buscar_alumno(notas,n);
break;
case 4:
cambiar_notas(notas,n);
break;
case 5:
eliminar_alumno(notas,n);
break;
}
}
}
int insertar_notas(struct alumnos notas[20], int n,int *id_alumno){
char resp[3];
system("cls");
puts("\n \a Insercion del alumno\n");
while (!strstr(resp,"no")){
fflush(stdin);
printf("\nEl ID de este alumno sera: %d\n", *id_alumno);
notas[n].id=*id_alumno;
(*id_alumno)++;
puts("\nDime el nombre del Alumno\n");
scanf("%10s", notas[n].alumno );
system("cls");
fflush(stdin);
puts("\nDime el apellido del Alumno\n");
scanf("%10s", notas[n].apellido );
system("cls");
puts("\nDime la Primera nota trimestral del Alumno[1.23]\n");
scanf("%f", &notas[n].nota1 );
system("cls");
puts("\nDime la Segunda nota trimestral del Alumno[1.23]\n");
scanf("%f", &notas[n].nota2 );
system("cls");
puts("\nDime la Tercera nota trimestral del Alumno[1.23]\n");
scanf("%f", &notas[n].nota3 );
n++;
system("cls");
puts("\nQuieres volver a insertar otro?[si|no]\n");
scanf("%3s", resp);
strlwr(resp);
}
return n;
}
void mostrar_notas(struct alumnos notas[20],int n){
int i;
system("cls");
if (n != 0 ){
puts("\nLos alumnos insertados son:\n");
for (i = 0; i < n; i++)
{
printf("\n\nID %d\n\n Nombre:%s\n Apellido: %s\n Primera nota:%0.2f\n Segunda nota:%0.2f\n Tercera nota:%0.2f\n\n", notas[i].id, notas[i].alumno, notas[i].apellido ,notas[i].nota1 ,notas[i].nota2 ,notas[i].nota3 );
}
}
else
{
puts("\n \aNo hay registro\n");
}
}
void buscar_alumno(struct alumnos notas[20],int n){
int num = 0;
float media;
if (n != 0){
char ape_alumno[15];
system("cls");
puts("\n\aBusqueda por alumno\n");
puts("\nDime el apellido del alumno\n");
scanf("%15s", ape_alumno);
for ( num = 0; num < n ; num++){
if (strcmp(notas[num].apellido,ape_alumno)==0){
printf("\nEl alumno introducido es: %s %s\n", notas[num].alumno, notas[num].apellido );
media=(notas[num].nota1+notas[num].nota2+notas[num].nota3)/3;
printf("\nLa nota media es %0.2f \n", media);
if (media<5){
puts("\nSuspendido no hace media\n");
}
if (media=5 & media>6){
puts("\nSuficiente\n");
}
}
}
}else{
puts("\a\nRegistro vacio\n");
}
}
void cambiar_notas(struct alumnos notas[20],int n){
char ape_notas[15];
float nueva_nota1,nueva_nota2,nueva_nota3,nota_n1t,nota_n2t,nota_n3t;
int j = 0, submenu_mod = 0, nota_mod;
if (n != 0){
system("cls");
puts("\n \aDime el apellido del alumno a modificar las notas\n");
scanf("%15s", ape_notas);
for (j = 0;j < n; j++){
if (strcmp(notas[j].apellido,ape_notas)==0){
printf("\nLas notas de este alumno %s %s son:\n \n1r Trimestre:%0.2f\n \n2n Trimestre:%0.2f\n \n3r Trimestre:%0.2f\n", notas[j].alumno,notas[j].apellido,notas[j].nota1 ,notas[j].nota2 ,notas[j].nota3 );
while(submenu_mod != 3){
puts("\nQue quieres hacer?:\n\n1)Modificar todas las notas\n2)Modificar solo una nota\n3)Salir\n");
scanf("%d", &submenu_mod);
switch(submenu_mod){
case 1:
puts("\nDime la primera nota trimestral\n");
scanf("%f", &nueva_nota1);
puts("\nDime la segunda nota trimestral\n");
scanf("%f", &nueva_nota2);
puts("\nDime la tercera nota trimestral\n");
scanf("%f", &nueva_nota3);
notas[j].nota1=nueva_nota1;
notas[j].nota2=nueva_nota2;
notas[j].nota3=nueva_nota3;
printf("\nLas nuevas notas de este alumno son:\n \n1r Trimestre:%0.2f\n \n2n Trimestre:%0.2f\n \n3r Trimestre:%0.2f\n", notas[j].nota1 ,notas[j].nota2 ,notas[j].nota3 );
system("pause");
break;
case 2:
while (nota_mod != 4){
puts("\nQue nota trimestral quieres modificar?:\n");
printf("\n1)Nota trimestral %0.2f\n2)Nota trimestral %0.2f\n3)Nota trimestral %0.2f\n4)Salir", notas[j].nota1,notas[j].nota2,notas[j].nota3);
scanf("%d", &nota_mod);
switch(nota_mod){
case 1:
puts("\nDime la nueva nota del Primer trimestre:\n");
scanf("%f", &nota_n1t);
notas[j].nota1=nota_n1t;
printf("La nueva nota del primer trimestre para el alumno %s %s es: \n%0.2f", notas[j].alumno,notas[j].apellido,notas[j].nota1);
break;
case 2:
puts("\nDime la nueva nota del Segundo trimestre:\n");
scanf("%f", &nota_n2t);
notas[j].nota2=nota_n2t;
printf("La nueva nota del Segundo trimestre para el alumno %s %s es: \n%0.2f", notas[j].alumno,notas[j].apellido,notas[j].nota2);
break;
case 3:
puts("\nDime la nueva nota del Tercer trimestre:\n");
scanf("%f", &nota_n3t);
notas[j].nota3=nota_n3t;
printf("La nueva nota del Tercer trimestre para el alumno %s %s es: \n%0.2f", notas[j].alumno,notas[j].apellido,notas[j].nota3);
break;
}
break;
}
}
}
} else {
puts("\nNo se ha encontrado ese apellido\n");
}
}
} else {
system("cls");
puts("\n \aRegistro vacio\n");
}
}
The function:
void eliminar_alumno(struct alumnos notas[20],int n){
int id_eli = 0, r = 0;
mostrar_notas(notas,n);
puts("\nInserta la id del alumno a eliminar\n");
scanf("%d",&id_eli);
for(r = 0;r < n;r++){
if (notas[r].id = id_eli){
notas[r].id=notas[r+1].id;
n--;
}
}
}
Compile with warnings:
if (notas[r].id = id_eli){
should be
if (notas[r].id == id_eli){
Also, this is wrong:
if (media=5 & media>6){
Suficiente = [5 - 6) right? Then you want if (media >= 5 && media < 6)
Try the following changes in your eliminar_alumno function-
for(r = 0;r < n;r++){
if (notas[r].id == id_eli){
for(i=r;i < (n-1);i++)
notas[i]=notas[i+1];
notas[i].id -= 1;
n--;
}
}

Unable to start the int correctly and keep the number back from the function

First at all sorry for my english, i will try my best.
Well, here's the problem, I am making a C program just for learning, the program is basically a students manager, I wanted to add a final function in which the user would be prompted by an id to by remove and after inserting that id the student would be eliminate from the database, the problem is... when the data is inserted in the first case there's added a subroutine that automatically adds the id as and int in the struct,problem is it shows a random int number like "43405" or so I thought to start the integer to 1, the problem is when the function is re-called again id will back to be 1 and that just simply don't work.
P.D:I read some of you guys told me about to make the code more readable, can you give me a nice "tutorial" or so to make that?
Function:
int insertar_notas(struct alumnos notas[20], int n,int id_alumno){
char resp[3];
system("cls");
puts("\n \a Insercion del alumno\n");
while (!strstr(resp,"no")){
fflush(stdin);
printf("\nEl ID de este alumno sera: %d\n", id_alumno);
notas[n].id=id_alumno;
id_alumno++;
puts("\nDime el nombre del Alumno\n");
scanf("%10s", notas[n].alumno );
system("cls");
fflush(stdin);
puts("\nDime el apellido del Alumno\n");
scanf("%10s", notas[n].apellido );
system("cls");
puts("\nDime la Primera nota trimestral del Alumno[1.23]\n");
scanf("%f", &notas[n].nota1 );
system("cls");
puts("\nDime la Segunda nota trimestral del Alumno[1.23]\n");
scanf("%f", &notas[n].nota2 );
system("cls");
puts("\nDime la Tercera nota trimestral del Alumno[1.23]\n");
scanf("%f", &notas[n].nota3 );
n++;
system("cls");
puts("\nQuieres volver a insertar otro?[si|no]\n");
scanf("%3s", resp);
strlwr(resp);
}
return n;
return id_alumno;
}
Main for more info:
int main (void){
int menu = 0, n = 0, id_alumno;
struct alumnos notas[20];
puts("\n<><><>Bienvenido al recuento de notas de la escuela<><><>\n");
puts("\nQue deseas hacer?\n");
while (menu != 5){
puts("\n1)Insertas las notas de un alumno\n2)Ver todas las notas\n3)Ver las notas de un alumno\n4)Modificar notas\n5)Salir\n");
scanf("%d", &menu);
switch(menu){
case 1:
n=insertar_notas(notas,n,id_alumno);
break;
C uses pass by value, so to make id_alumno modifiable you need to pass it as a pointer:
int insertar_notas(struct alumnos notas[20], int n,int *id_alumno) { // id_alumno is now a pointer to int inside this function
char resp[3];
system("cls");
puts("\n \a Insercion del alumno\n");
while (!strstr(resp,"no")){
fflush(stdin);
printf("\nEl ID de este alumno sera: %d\n", *id_alumno); // Use * to access the value
notas[n].id=id_alumno;
(*id_alumno)++; // Use * to access the value. ++ has higher precedence than *, so need parenthesis around *id_alumno
...
And in the call from main:
n=insertar_notas(notas, n, &id_alumno); // address-of id_alumno
Also, you need to initialize id_alumno in main:
int menu = 0, n = 0, id_alumno = 1;

Resources