gente pra quem não entendeu acho que é tipo isso: #include struct horario // estrutura global do tipo horario contendo 3 variaveis do tipo int { int horas, minutos, segundos; }; int main() { struct horario teste(struct horario x); // declara que existe uma função estruct do //tipo horario de nome teste que retorne uma struct do tipo horario de nome qualquer.
struct horario agora;// declara uma struct do tipo horario chamada agora agora. horas = 10;// atribui os valores das 3 variaveis da struct horario agora agora. minutos = 42; agora. segundos = 58; struct horario proxima;//declara uma struct do tipo horario chamada proxima proxima = teste(agora);// nesse momento para saber o valor de proxima o //compilador executa o que está na função teste sabendo que ela deve retornar a struct //horario agora, dentro de teste como podemos ver abaixo a primeira coisa a ser //executada é um printf retornando os valores das três variaveis de AGORA e depois //altera essas três variaveis e o comando return faz com que as variaveis assumam //esses novos valores, ou seja, aparece na tela "10, 42, 58" e logo depois muda esses valores para "100, 100, 100" printf("%i : %i : %i ", proxima. horas, proxima. minutos, proxima. segundos); // esse printf retorna o valor das variaveis de proxima, proxima = teste(agora), ou seja //quando alteramos os valores de "10, 42, 58" dentro da função teste para "100, 100, //100" mudamos também os valores das variaveis contidas em proxima. assim esse //printf retorna "100, 100, 100" system("pause"); } struct horario teste(struct horario x){ printf("%i : %i : %i ", x. horas, x. minutos, x. segundos); x. horas = 100; x. minutos = 100; x. segundos = 100;
Voçê está de parabéns pela iniciativa, sou estudante de Sistemas de Informação e estou com dificuldades na disciplina de Estrutura de Dados em C, e suas aulas tem me ajudado bastante. Valeu Irmão! ...
Já ví outras aulas e são ótimas, mas esta especificamente está confusa. São muitas informações. Para um principiante como eu o entendimento fica difícil. Acho que vale a pena o professor revisar e simplificar esta aula. Mas está de parabéns de qualquer forma.
Nossa.. tive que assistir umas 15 vezes para entender. e reescrever umas 30. Mas acabei entendendo,. Muito obrigado professor, Seria bom se vc disponibilizasse o codigo fonte de cada programa na descrição do video.
Antes de assistir os vídeos, vi que muitos comentários de pessoas confusas com esta aula. O que me deixou bastante apreensivo se eu iria conseguir ou não continuar acompanhando a playlist, mas após assistir o vídeo não tive dificuldade alguma de entender, creio que o erro na hora de printar a estrutura x em vez de proxima e a declaração da struct já de início tenha deixado algumas pessoas confusas. Mas é algo simples de entender e muito importante de se aprender. Muito obrigado por compartilhar mais uma aula incrível prof. =)
Essa foi dificil, mas eu entendi e reforçou os conceitos de função que eu precisava!!!! temos que nos atentar a base de uma função!! _tipo_nome_parametros_ essa estrutura vale pra tudo!!!
cara muito boa sua aula , aliás todas são muito boas ! ta de parabéns ! to fazendo eng eletrônica e meu prof de linguagem c eh um lix... vc não tem noção de como está me ajudando o seu canal ! vlw cara !!!
O pessoal que ficou confuso foi devido a misturar struct com função, que de fato vai causar uma estranheza mesmo. No meu meio acadêmico, em nenhum momento tive aulas misturando struct com funções. Mas revendo o vídeo algumas vezes da para clarear as ideias. Volta a postar vídeo mano!1!! kkkk
Oiê! Uma dúvida: uma função só retorna um valor por vez, correto? Então esse retorno da variavel x, dentro da função, colocaria apenas o ultimo valor dentro da variavel proxima do tipo estruct? desde já, muito obrigada por suas aulas
Pessoal, tenho a seguinte dúvida: Quando à parte: proxima = teste (agora); (linha 19) é essa linha do programa que faz printar o "10:42:58" no resultado final quando o programa roda? Ou seja, a linha 19 por si só estaria fazendo na verdade duas coisas: printando o "10:42:58" e tb atribuindo à variável proxima a saída da função teste? Desde já agradeço pela atenção!
cara vc deveria fazer o video 42 parte II e esplicar o que vc disse nesse video no paint ou photoshop escrevendo e desenhando ficou muito foda de entender.
Eu li os comentários e fiquei até com medo de ver o vídeo, mas eu vi e não encontrei nenhuma dificuldade. Ele só disse que temos que escrever a definição da estrutura fora de todas as funções, como se fosse uma variável global, para que todas as funções do código possam enxergar essa definição de estrutura. Do mais não tem nada de novidade, só o tamanho do nome das variáveis que mudou pelo fato de que quando você trabalha com uma estrutura é necessário colocar o nome da estrutura e o nome da definição da estrutura. Nada de pânico pessoal. Não critiquem a explicação. Acredito que pra quem ficou confuso, ficará mais claro se assistir a aula de funções de novo. Espero ter ajudado, abraço.
E quando tem campos string? E é preciso pegar este campo como em um scanf, como fazer? Estou recebendo como parametro uma estrutura para processar fazendo os gets necessários. Mas neste tipo de campo não funciona.
Pra quem não entendeu, analise o código abaixo, o conceito é simples, mas o que pode confundir é: int quadrado(int base); //Declarando o protótipo de uma função chamada "quadrado" que retorna um valor do tipo int e recebe um valor do tipo int como parâmetro Perceba que o int antes de "quadrado" é o tipo de retorno, no exemplo do vídeo: struct horario teste(struct horario x); //Dessa vez, struct horario é o tipo de retorno, ou seja, a função "teste" retorna uma variável do tipo struct horario Na hora de declarar o tipo de retorno deve-se colocar a palavra reservada "struct", e é isso que confunde. [int] quadrado(int base); //O int entre colchetes é o tipo de retorno da função [struct horario] teste(struct horario x); //O struct horario entre colchetes é o tipo de retorno da função int quadrado([int] base); //Perceba que antes de "base" deve-se colocar o tipo da variável que a função recebe como parâmetro, ou seja, a função "quadrado" recebe uma variável do tipo int como parâmetro struct horario teste([struct horario] x); //A função "teste" recebe uma variável do tipo struct horario como parâmetro Se alguém tiver alguma dúvida e quiser me perguntar, posso tentar ajudar! O código está abaixo: #include #include #include struct horario { //A struct deve obrigatoriamente ser declarada fora da função principal, é como se ela fosse uma variável global //Se a struct estiver dentro da função principal, ela não será visível para as funções externas int horas, minutos, segundos; double x; char letra; }; struct horario funcao(struct horario x); //tipo de retorno nome(tipo parâmetro 1); //struct horario é um tipo de dado //Por exemplo: //[int] contador; //[struct horario] contador; //A palavra struct deve fazer parte da declaração do tipo, ou seja, o tipo deve ser escrito como struct, seguido do nome da estrutura e do nome da variável int main(void) { struct horario agora;
struct horario retornoDaFuncao; //Criando uma outra variável do tipo struct horario chamada retornoDaFuncao
//retornoDaFuncao é uma variável do tipo struct horario //Ela recebe o retorno da função "funcao": retornoDaFuncao = funcao(agora); //Invocando a função "funcao" e passando uma variável chamada "agora" do tipo struct horario como argumento
printf("Exibindo os dados da variável \ do tipo struct horario: horas == %d minutos == %d x = %.2f", retornoDaFuncao.horas, retornoDaFuncao.minutos, retornoDaFuncao.x);
getch(); return 0; } //A função "funcao" recebe uma variável do tipo struct horario como parâmetro e retorna uma variável do tipo struct horario: struct horario funcao(struct horario x) { printf(" Dentro da Função %d:%d:%d
Colocando os dois printfs na outra função fica mas fácil ainda,dai é só chamar a outra função sem precisar criar outra estrutura pra obter os valores alterados. #include #include struct horario{ int hora; int minutos; int segundos; }; int main(){ struct horario agora; agora.hora = 12; agora.minutos = 34; agora.segundos = 22; struct horario teste(struct horario x); teste(agora); system("pause"); return 0; } struct horario teste(struct horario recebe){ printf("%i:%i:%i
Eu queria saber como que seria a resolução se a função teste tivesse dois parâmetros. Ex: struct horario teste(struct horario x,struct horario y); Entendeu ?
Obrigado mais uma vez!Se puder ajudar fiz o código no Devc ++ porém não está sendo executado todo o código.Link da minha dúvida no Fórum : groups.google.com/forum/?hl=pt-BR#!category-topic/dealunoparaaluno/c/KCk0kNZKaiQ
A explicação para quem já tem intimidade com o assunto é boa porém o exemplo dado acho que dificultou um pouco o entendimento para alguns, talvez o cálculo de alguma área funcionaria melhor Obrigado;
Voltar o video, tentar refazer tudo sozinho, refazer mais vezes passo a passo. É muito bom fazer isso antes de ficar de mimimi nos coments falando que ele não explica corretamente.
Pq o tipo já foi declarado na definição da estrutura. É semelhante a quando vc define uma variável e dps só altera o valor dela, sem mencionar o tipo, pois o mesmo já foi definido.
Nesse caso você esta passando a struct de tipo horario (com o nome agora) como parâmetro, o esqueleto do struct é o que precisa ser como global, já que outras funções que retornam valor de tipo struct precisam identificar o esqueleto da struct para alterar os valores de outras struct do mesmo tipo.
ele simplesmente criou uma variavel para a estrutura global horario// que pode ser usada por todas as funçoes adicionou pra cada as 3 variaveis um valor, dentro dessa variavel criou a funçao teste para a estrutura horário com um parametro: teste(valor do tipo HORARIO)//OU SEJA! a variavel agora ou a variavel proxima por que? porque elas sao do tipo HORARIO dai o parametro que a funçao teste recebe vai ser a variavel "agora" que ja tem dentro dela todos as variaveis com os valores organizados que na funçao main foram editados.. agora.horas=1,agora.minutos=30 e etc entao ele simplesmente retornou a variavel "agora" que é recebida pela a variavel "proxima" todos os valores dela entao seria a mesma coisa que isso: proxima.horas=1//valor da variavel agora proxima.minutos=30//valor da variavel agora
// Código testado no Code::Block // Sempre prefiro definir um novo tipo usando // estruturas, não sei se é a forma mais adequada // mas considero mais legível. typedef struct{ unsigned short horas, minutos, segundos; }THora; // sem retorno apenas para prova // de conceito void relogio(THora x); int main(void) { THora agora; agora.horas=15; agora.minutos=11; agora.segundos=46;
Para quem não entendeu: Dêm UP pra ficar no topo! O programa fica mais fácil de compreender se o código for escrito desta maneira: #include struct horario{ int horas, minutos, segundos; }; struct horario teste(struct horario x){ printf("STRUCT HORARIO TESTE(STRUCT HORARIO): %d %d %d ", x.horas, x.minutos, x.segundos); x.horas=100; x.minutos=100; x.segundos=100; return x; } int main(void){ struct horario agora; agora.horas=10; agora.minutos=42; agora.segundos=58; struct horario proxima; proxima=teste(agora); printf("STRUCT HORARIO PROXIMA: %d %d %d ", proxima.horas, proxima.minutos, proxima.segundos); return 0; } Explicação: Foi criada uma Estrutura do tipo "horário", que contém 3 variáveis: horas, minutos, segundos. (struct horario) Em int main(void), foi criada uma Estrutura do tipo "horário" chamada "agora", e o que aconteceu foi que as 3 variáveis "horas, minutos, segundos", anteriormente definidas em struct horario, receberam valores, pertencendo à struct horario agora, daí alterarmos a sintax para agora.horas, agora.minutos e agora.segundos. Isso significa que fizemos com que as variáveis horas, minutos e segundos fossem "transformadas" em variáveis pertencentes à estrutura horario agora. Finalmente, dissemos que essas variáveis recebiam os valores 10, 42 e 58. Ainda em main, criamos uma estrutura do tipo horario chamada "proxima". Quando escrevemos, na proxima linha, proxima=teste(agora), dissemos que struct horario proxima receberia o conteúdo de teste(agora), e isso significa o seguinte: teste(agora) siginifica que atribuímos à estrutura chamada "teste", o conteúdo da estrutura chamada "agora" que era "agora.horas=10; agora.minutos=42; agora.segundos=58;". Ou seja, a funçao struct horario teste recebeu o "agora.horas=10; agora.minutos=42; agora.segundos=58;", e é por isso que aparece no printf dentro de struct horario teste(struct horario x). E o que significa struct horario teste(struct horario x)? struct horario teste(struct horario x) significa que a estrutura horario chamada teste tem como argumento uma estrutura do tipo horario chamada x, que é nada mais nada menos que uma variável pertencente a struct horario teste. Pode parecer estranho que x.horas, x.minutos e x.segundos receba 10, 42 e 58, mas isso acontece porque em main tinhamos dito que "teste" recebia "agora" (proxima=teste(agora)). Depois, quando fazemos x.horas=100; x.minutos=100; e x.segundos=100;, estamos nada mais nada menos a dizer que "x.horas já nao é 10, x.minutos ja nao é 42 e x.segundos ja nao é 58. Serão agora igual a 100, e vou retornar esses valores para a main, fazendo "return x". E onde é que esse retorno acontece? Acontece quando dizemos que proxima é igual a teste agora, ou seja, com o comando "proxima=teste(agora)". Nessa altura, a temos que proxima.horas=proxima.minutos=proxima.segundos, ou seja, igual a 100. Se tiverem duvidas comentem aí em baixo para que possa explicar melhor. É difícil explicar com texto, fiz o meu melhor gente, desculpem qualquer coisa! Espero que tenham entendido, bom estudos e obrigado ao canal pelas excelentes aulas!
Acho que o problema que muitos estão enfrentando para entender essa aula é o seguinte: Esse conteúdo deveria ser ensinado separado antes. de forma simplificada, junto com função deixa confuso.
Sim, não senti dificuldade em entender pois trabalho bastante com funções. O fato de que teve bastante informação para apenas uma aula foi o que deixou alguns confusos, mas sem dúvidas uma parte || desse vídeo seria bastante esclarecedor.
A aula é ótima de entender para quem está aqui desde as primeiras aulas, mas claramente quem caiu de paraquedas vai ficar boiando. Vejam as aulas anteriores pessoal!
Eu acho que o pessoal não entendeu quando ele trocou o nome do parâmetro q vai na estrutura, usando apenas 'x', consideraram mt informação. Extrapolou o limite kkkkkkkkkkkkkkkkk e talvez n tenham entendido a funcionalidade do ponto q capta o membro de um objeto. Eu n digo nd. Cheguei a aula 42 em poucas horas, só pulando... eu sou muito burro. Tenho que ficar revendo o básico sempre. A lógica do vídeo tá fácil te entender. Mas uma coisa é verdade: se você não praticar, não aprende nunca. Aprendi struct essa semana, mas há mt tempo insisto nisso. Coisa de anos em programação. Já desisti mts vzs.
+Thiago Teles ele montou esse curso abrangendo a maioria dos assuntos necessários para a programação, mas o curso funciona de modo que ele só dá exemplos com assuntos que ele já ensinou. Como ele ainda não ensinou ponteiros nas aulas anteriores, provável que seja o motivo de ele não ter usado.
Após anos, esse segue sendo um dos melhores cursos de Linguagem C que já consultei. Obrigado! Abraço
gente pra quem não entendeu acho que é tipo isso:
#include
struct horario // estrutura global do tipo horario contendo 3 variaveis do tipo int
{
int horas, minutos, segundos;
};
int main()
{
struct horario teste(struct horario x); // declara que existe uma função estruct do //tipo horario de nome teste que retorne uma struct do tipo horario de nome qualquer.
struct horario agora;// declara uma struct do tipo horario chamada agora
agora. horas = 10;// atribui os valores das 3 variaveis da struct horario agora
agora. minutos = 42;
agora. segundos = 58;
struct horario proxima;//declara uma struct do tipo horario chamada proxima
proxima = teste(agora);// nesse momento para saber o valor de proxima o //compilador executa o que está na função teste sabendo que ela deve retornar a struct //horario agora, dentro de teste como podemos ver abaixo a primeira coisa a ser //executada é um printf retornando os valores das três variaveis de AGORA e depois //altera essas três variaveis e o comando return faz com que as variaveis assumam //esses novos valores, ou seja, aparece na tela "10, 42, 58" e logo depois muda esses valores para "100, 100, 100"
printf("%i : %i : %i
", proxima. horas, proxima. minutos, proxima. segundos);
// esse printf retorna o valor das variaveis de proxima, proxima = teste(agora), ou seja //quando alteramos os valores de "10, 42, 58" dentro da função teste para "100, 100, //100" mudamos também os valores das variaveis contidas em proxima. assim esse //printf retorna "100, 100, 100"
system("pause");
}
struct horario teste(struct horario x){
printf("%i : %i : %i
", x. horas, x. minutos, x. segundos);
x. horas = 100;
x. minutos = 100;
x. segundos = 100;
return x;
}
ESPERO TER AJUDADO, ABRAÇOS.
#include
#include
struct horario{
int hora;
int minuto;
int segundo;
};
struct horario imprime(struct horario); //Cabeçalho
int main(){
setlocale(LC_ALL, "Portuguese");
struct horario horaAtual;
horaAtual.hora = 15;
horaAtual.minuto = 20;
horaAtual.segundo = 49;
printf("Horário agora no MAIN: %d:%d:%d
", horaAtual.hora, horaAtual.minuto, horaAtual.segundo);
imprime(horaAtual);
system("pause");
return 0;
}
struct horario imprime(struct horario x){ //struct horario como função, quer dizer q retorna uma estrutura
x.hora= 100;
x.minuto = 200;
x.segundo = 300;
printf("Horario com função: %d:%d:%d
", x.hora, x.minuto, x.segundo);
return x;
};
RONALDO GONÇALVES saberia informar como a struct teste sabe diferenciá q foi atribuída agora e não próximo ? Obrigado pela atenção
valeu pela ajuda, parceiro!
@@jeffersoncastro9373 O parâmetro que foi passado para a funçao teste foi (agora).
Unica video aula que eu nao entendi até agora! muito bom as aulas!
Voçê está de parabéns pela iniciativa, sou estudante de Sistemas de Informação e estou com dificuldades na disciplina de Estrutura de Dados em C, e suas aulas tem me ajudado bastante. Valeu Irmão! ...
Já ví outras aulas e são ótimas, mas esta especificamente está confusa. São muitas informações.
Para um principiante como eu o entendimento fica difícil. Acho que vale a pena o professor revisar
e simplificar esta aula. Mas está de parabéns de qualquer forma.
Estou estudando para a faculdade e to com dificuldade, caso possa tirar uma duvida que estou em um exercício agradeço.
é por que é outro cara kkkkkkkkkk
Nossa.. tive que assistir umas 15 vezes para entender. e reescrever umas 30. Mas acabei entendendo,. Muito obrigado professor, Seria bom se vc disponibilizasse o codigo fonte de cada programa na descrição do video.
Antes de assistir os vídeos, vi que muitos comentários de pessoas confusas com esta aula. O que me deixou bastante apreensivo se eu iria conseguir ou não continuar acompanhando a playlist, mas após assistir o vídeo não tive dificuldade alguma de entender, creio que o erro na hora de printar a estrutura x em vez de proxima e a declaração da struct já de início tenha deixado algumas pessoas confusas. Mas é algo simples de entender e muito importante de se aprender.
Muito obrigado por compartilhar mais uma aula incrível prof. =)
10 anos ja ! :o, este canal me ajudou muito ! hoje sou arquiteto de sw.
Tá de parabéns, cara meu professor fala, fala, fala, e não entendo nada, aprendo tudo com você e estou tendo ótimos resultados, parabéns. Nota 10 !
Essa foi dificil, mas eu entendi e reforçou os conceitos de função que eu precisava!!!! temos que nos atentar a base de uma função!! _tipo_nome_parametros_ essa estrutura vale pra tudo!!!
cara muito boa sua aula , aliás todas são muito boas ! ta de parabéns ! to fazendo eng eletrônica e meu prof de linguagem c eh um lix... vc não tem noção de como está me ajudando o seu canal ! vlw cara !!!
ESSES VIDEOS SÃO UM PATRIMONIO DA HUMANIDADE SO TENHO A DIZER OBRIGADO
Excelente aulas. Top de mais. Estava precisando entender como retornar uma estrutura na função.
O pessoal que ficou confuso foi devido a misturar struct com função, que de fato vai causar uma estranheza mesmo.
No meu meio acadêmico, em nenhum momento tive aulas misturando struct com funções.
Mas revendo o vídeo algumas vezes da para clarear as ideias.
Volta a postar vídeo mano!1!! kkkk
Complicado mas entendi, vou anotando e escrevendo o que entendi! Obrigado pelas aulas!
mano as tuas aulas ajudam muito...muito obrigado
alguém assistindo em 2021?
excelente! struct horario teste(struct horario x); penso que devera ser colocado antes do int main(void)
Exatamente, no começo me confundi pois geralmente os protótipos são anunciados fora da main.
gostei muito..... parabéns.... calmo e claramente explicado...
Valeu!
Já assisti muitos vídeos. Me tirou muitas duvidas. Obrigado
Parabéns Professor excelente aula.
Oiê! Uma dúvida: uma função só retorna um valor por vez, correto? Então esse retorno da variavel x, dentro da função, colocaria apenas o ultimo valor dentro da variavel proxima do tipo estruct?
desde já, muito obrigada por suas aulas
Pessoal, tenho a seguinte dúvida:
Quando à parte:
proxima = teste (agora); (linha 19)
é essa linha do programa que faz printar o "10:42:58" no resultado final quando o programa roda?
Ou seja, a linha 19 por si só estaria fazendo na verdade duas coisas: printando o "10:42:58" e tb atribuindo à variável proxima a saída da função teste?
Desde já agradeço pela atenção!
Sim é isso mesmo
A linha 19 é responsavel por printar 10:42:58 e atribui o retorno da função teste a variavel proxima
@@gustavobacagine , ok, valeu, obrigado! 👍
cara vc deveria fazer o video 42 parte II e esplicar o que vc disse nesse video no paint ou photoshop escrevendo e desenhando ficou muito foda de entender.
+carlos diego urbano melo Concordo ficou confuso demais...
Galera, vcs saberiam informar como a struct teste sabe diferenciá q foi atribuída agora e não próximo? Obrigado pela atenção
Demora, mas estou conseguindo aprender o que foi passado, ótima aula.
postei lá
Eu li os comentários e fiquei até com medo de ver o vídeo, mas eu vi e não encontrei nenhuma dificuldade. Ele só disse que temos que escrever a definição da estrutura fora de todas as funções, como se fosse uma variável global, para que todas as funções do código possam enxergar essa definição de estrutura. Do mais não tem nada de novidade, só o tamanho do nome das variáveis que mudou pelo fato de que quando você trabalha com uma estrutura é necessário colocar o nome da estrutura e o nome da definição da estrutura.
Nada de pânico pessoal. Não critiquem a explicação. Acredito que pra quem ficou confuso, ficará mais claro se assistir a aula de funções de novo.
Espero ter ajudado, abraço.
E quando tem campos string? E é preciso pegar este campo como em um scanf, como fazer?
Estou recebendo como parametro uma estrutura para processar fazendo os gets necessários. Mas neste tipo de campo não funciona.
thanks teacher, it realy help me a lot.
Pra quem não entendeu, analise o código abaixo, o conceito é simples, mas o que pode confundir é:
int quadrado(int base); //Declarando o protótipo de uma função chamada "quadrado" que retorna um valor do tipo int e recebe um valor do tipo int como parâmetro
Perceba que o int antes de "quadrado" é o tipo de retorno, no exemplo do vídeo:
struct horario teste(struct horario x); //Dessa vez, struct horario é o tipo de retorno, ou seja, a função "teste" retorna uma variável do tipo struct horario
Na hora de declarar o tipo de retorno deve-se colocar a palavra reservada "struct", e é isso que confunde.
[int] quadrado(int base); //O int entre colchetes é o tipo de retorno da função
[struct horario] teste(struct horario x); //O struct horario entre colchetes é o tipo de retorno da função
int quadrado([int] base); //Perceba que antes de "base" deve-se colocar o tipo da variável que a função recebe como parâmetro, ou seja, a função "quadrado" recebe uma variável do tipo int como parâmetro
struct horario teste([struct horario] x); //A função "teste" recebe uma variável do tipo struct horario como parâmetro
Se alguém tiver alguma dúvida e quiser me perguntar, posso tentar ajudar!
O código está abaixo:
#include
#include
#include
struct horario { //A struct deve obrigatoriamente ser declarada fora da função principal, é como se ela fosse uma variável global
//Se a struct estiver dentro da função principal, ela não será visível para as funções externas
int horas, minutos, segundos;
double x;
char letra;
};
struct horario funcao(struct horario x);
//tipo de retorno nome(tipo parâmetro 1);
//struct horario é um tipo de dado
//Por exemplo:
//[int] contador;
//[struct horario] contador;
//A palavra struct deve fazer parte da declaração do tipo, ou seja, o tipo deve ser escrito como struct, seguido do nome da estrutura e do nome da variável
int main(void) {
struct horario agora;
setlocale(LC_ALL, "Portuguese");
agora.horas = 18;
agora.minutos = 20;
agora.segundos = 42;
struct horario retornoDaFuncao; //Criando uma outra variável do tipo struct horario chamada retornoDaFuncao
//retornoDaFuncao é uma variável do tipo struct horario
//Ela recebe o retorno da função "funcao":
retornoDaFuncao = funcao(agora); //Invocando a função "funcao" e passando uma variável chamada "agora" do tipo struct horario como argumento
printf("Exibindo os dados da variável \ do tipo struct horario:
horas == %d
minutos == %d
x = %.2f", retornoDaFuncao.horas, retornoDaFuncao.minutos, retornoDaFuncao.x);
getch();
return 0;
}
//A função "funcao" recebe uma variável do tipo struct horario como parâmetro e retorna uma variável do tipo struct horario:
struct horario funcao(struct horario x) {
printf(" Dentro da Função
%d:%d:%d
", x.horas, x.minutos, x.segundos);
x.horas = 22;
x.minutos = 50;
x.x = 8950.55;
return x;
}
Colocando os dois printfs na outra função fica mas fácil ainda,dai é só chamar a outra função sem precisar criar outra estrutura pra obter os valores alterados.
#include
#include
struct horario{
int hora;
int minutos;
int segundos;
};
int main(){
struct horario agora;
agora.hora = 12;
agora.minutos = 34;
agora.segundos = 22;
struct horario teste(struct horario x);
teste(agora);
system("pause");
return 0;
}
struct horario teste(struct horario recebe){
printf("%i:%i:%i
",recebe.hora,recebe.minutos,recebe.segundos);
recebe.hora = 22;
recebe.minutos = 34;
recebe.segundos = 12;
printf("%i:%i:%i
",recebe.hora,recebe.minutos,recebe.segundos);
}
Interessante, porém fiquei com dúvida na parte da alteração dos valores em próxima. Como ocorreu a alteração sem que houvesse apontamento na memória?
A voz dele eh muito boa. A didática também. :3
Alguém ainda assiste em 2019 ?
Assisto em 2020. Legal interagir com pessoas que estão em outra época. Depois conto para vocês o bug que vai acontecer em 2020. Vai ser surreal.
@@sergiofernandes1313 kkkkkkkk Se dps aparecer alguém do futuro (Talvez 2021) queria saber se o mundo ainda existe
Existe kkkkkkkkk
@@jaum_https existe e está ficando pior a cada dia kkk
2021
Eu queria saber como que seria a resolução se a função teste tivesse dois parâmetros. Ex: struct horario teste(struct horario x,struct horario y); Entendeu ?
No meu deu erro no processamento, "proxima = teste(agora);", poderia ajudar alguém? Uso DEV C ++.
vlw ajudou muito!
não entendo o porque de fazer o código igaul no vídeo e da erro de compilação, não tá copilando. eu estou usando o devc++
Até a aula 40 entendi tudo, pula para 42, não entendi nada.... Função (x) etc... ficou meio confuso....
É só ir com calma que tu chega lá
Como passar um vetor de struct como parametro em uma função ?
eu entendo funçoes,parametros,struct e tal...
mas nao entendi essa linha 11 :struct horario teste(struct horario x);
Essa é a declaração da função teste de tipo struct horario, que recebe um valor de tipo struct horario que vai passar a ter o nome x.
Ola! muito bom! Gostaria de saber como ficaria este mesmo programa com a struct usando typedef? Tentei fazer, mas não deu...
obrigado.
Obrigado mais uma vez!Se puder ajudar fiz o código no Devc ++ porém não está sendo executado todo o código.Link da minha dúvida no Fórum : groups.google.com/forum/?hl=pt-BR#!category-topic/dealunoparaaluno/c/KCk0kNZKaiQ
A explicação para quem já tem intimidade com o assunto é boa porém o exemplo dado acho que dificultou um pouco o entendimento para alguns, talvez o cálculo de alguma área funcionaria melhor
Obrigado;
Cara muito confuso ja voltei o video umas 10 vezes....
+Joao Paulo Veras Tá muito simples, mas precisa ver as aulas de funções antes...
+Joao Paulo Veras tá meio embolado essas estruturas e funções msm.
Vou verificar!
Voltar o video, tentar refazer tudo sozinho, refazer mais vezes passo a passo. É muito bom fazer isso antes de ficar de mimimi nos coments falando que ele não explica corretamente.
mas nesse caso por que não é preciso colocar o tipo do valor.
Ex: int agora.segundos ??????
Pq o tipo já foi declarado na definição da estrutura. É semelhante a quando vc define uma variável e dps só altera o valor dela, sem mencionar o tipo, pois o mesmo já foi definido.
certo obg!
cadê a aula 41 ????
mas por que voce escreveu teste na funçao?
entendi muito fácil
voce tem uma didatica boa, não ensina outras linguagens tbm?
eu fiz assim
struct horario teste(struct horario x){
printf("%i : %i : %i
", x.horas, x.minutos, x.segundos );
x.horas = 100 ;
x.minutos = 250 ;
x.segundos = 360 ;
printf("%i : %i : %i
", x.horas, x.minutos, x.segundos );
return x ;
e funcionou normalmente, sem precisar colocar o prxouma.horas
não sei o porque de passar uma struct como parametro se vc colocou a struct como variavel global
Nesse caso você esta passando a struct de tipo horario (com o nome agora) como parâmetro, o esqueleto do struct é o que precisa ser como global, já que outras funções que retornam valor de tipo struct precisam identificar o esqueleto da struct para alterar os valores de outras struct do mesmo tipo.
Essa aula tá panck
Boa aula fessor, mas vai de leve no teclado ai. Abcs
por isso eu prefiro usar um compilador em linha de comando, ele já diz qual é o erro
a aula ficou confusa por excesso de informações
dps de rever algumas vezes eu entendi
minha cabeça bugou na primeira vez kkkkkkk
Tem um exemplo de quando vou usar STRUCT, em que situaçao vou usar.
A simples vista parece que nao tem muito sentido usar struct.
ele simplesmente criou uma variavel para a estrutura global horario// que pode ser usada por todas as funçoes
adicionou pra cada as 3 variaveis um valor, dentro dessa variavel
criou a funçao teste para a estrutura horário com um parametro: teste(valor do tipo HORARIO)//OU SEJA! a variavel agora ou a variavel proxima por que? porque elas sao do tipo HORARIO
dai o parametro que a funçao teste recebe vai ser a variavel "agora" que ja tem dentro dela todos as variaveis com os valores organizados que na funçao main foram editados.. agora.horas=1,agora.minutos=30 e etc
entao ele simplesmente retornou a variavel "agora" que é recebida pela a variavel "proxima" todos os valores dela
entao seria a mesma coisa que isso:
proxima.horas=1//valor da variavel agora
proxima.minutos=30//valor da variavel agora
Assim, no começo eu não tava entendendo nada, mas ai pro final, parecia que eu tava no começo y.y
Não entendi isto:
struct horario teste(struct horario x)
// Código testado no Code::Block
// Sempre prefiro definir um novo tipo usando
// estruturas, não sei se é a forma mais adequada
// mas considero mais legível.
typedef struct{
unsigned short horas,
minutos,
segundos;
}THora;
// sem retorno apenas para prova
// de conceito
void relogio(THora x);
int main(void)
{
THora agora;
agora.horas=15;
agora.minutos=11;
agora.segundos=46;
relogio(agora);
return 0;
}
void relogio(THora x)
{
printf("Hora: %d
",x.horas);
printf("Minutos: %d
",x.minutos);
printf("Segundos: %d
",x.segundos);
}
aqui vai o cod: #include
#include
struct horario {
int horas;
int minutos;
int segundos;
};
struct horario teste(struct horario x){
printf("%i:%i:%i
", x.horas,
x.minutos,
x.segundos);
x.horas = 100;
x.minutos = 100;
x.segundos = 100;
return x;
}
int main() {
struct horario agora;
agora.horas = 10;
agora.minutos = 42;
agora.segundos = 58;
struct horario proxima;
proxima = teste(agora);
printf("%i:%i:%i
", proxima.horas,
proxima.minutos,
proxima.segundos);
return 0;
}
//tecniphone lixa +351 962358552
Essa aula eu não entendi. Na realidade, não entendi pra que fez isso.
Já entendeu o que são funções?
Para quem não entendeu: Dêm UP pra ficar no topo!
O programa fica mais fácil de compreender se o código for escrito desta maneira:
#include
struct horario{
int horas, minutos, segundos;
};
struct horario teste(struct horario x){
printf("STRUCT HORARIO TESTE(STRUCT HORARIO):
%d %d %d
", x.horas, x.minutos, x.segundos);
x.horas=100;
x.minutos=100;
x.segundos=100;
return x;
}
int main(void){
struct horario agora;
agora.horas=10;
agora.minutos=42;
agora.segundos=58;
struct horario proxima;
proxima=teste(agora);
printf("STRUCT HORARIO PROXIMA:
%d %d %d
", proxima.horas, proxima.minutos, proxima.segundos);
return 0;
}
Explicação:
Foi criada uma Estrutura do tipo "horário", que contém 3 variáveis: horas, minutos, segundos.
(struct horario)
Em int main(void), foi criada uma Estrutura do tipo "horário" chamada "agora", e o que aconteceu foi que as 3 variáveis "horas, minutos, segundos", anteriormente definidas em struct horario, receberam valores, pertencendo à struct horario agora, daí alterarmos a sintax para agora.horas, agora.minutos e agora.segundos. Isso significa que fizemos com que as variáveis horas, minutos e segundos fossem "transformadas" em variáveis pertencentes à estrutura horario agora. Finalmente, dissemos que essas variáveis recebiam os valores 10, 42 e 58.
Ainda em main, criamos uma estrutura do tipo horario chamada "proxima". Quando escrevemos, na proxima linha, proxima=teste(agora), dissemos que struct horario proxima receberia o conteúdo de teste(agora), e isso significa o seguinte:
teste(agora) siginifica que atribuímos à estrutura chamada "teste", o conteúdo da estrutura chamada "agora" que era "agora.horas=10;
agora.minutos=42; agora.segundos=58;". Ou seja, a funçao struct horario teste recebeu o "agora.horas=10;
agora.minutos=42; agora.segundos=58;", e é por isso que aparece no printf dentro de struct horario teste(struct horario x).
E o que significa struct horario teste(struct horario x)? struct horario teste(struct horario x) significa que a estrutura horario chamada teste tem como argumento uma estrutura do tipo horario chamada x, que é nada mais nada menos que uma variável pertencente a struct horario teste. Pode parecer estranho que x.horas, x.minutos e x.segundos receba 10, 42 e 58, mas isso acontece porque em main tinhamos dito que "teste" recebia "agora" (proxima=teste(agora)).
Depois, quando fazemos x.horas=100; x.minutos=100; e x.segundos=100;, estamos nada mais nada menos a dizer que "x.horas já nao é 10, x.minutos ja nao é 42 e x.segundos ja nao é 58. Serão agora igual a 100, e vou retornar esses valores para a main, fazendo "return x". E onde é que esse retorno acontece? Acontece quando dizemos que proxima é igual a teste agora, ou seja, com o comando "proxima=teste(agora)". Nessa altura, a temos que proxima.horas=proxima.minutos=proxima.segundos, ou seja, igual a 100.
Se tiverem duvidas comentem aí em baixo para que possa explicar melhor. É difícil explicar com texto, fiz o meu melhor gente, desculpem qualquer coisa! Espero que tenham entendido, bom estudos e obrigado ao canal pelas excelentes aulas!
Acho que o problema que muitos estão enfrentando para entender essa aula é o seguinte: Esse conteúdo deveria ser ensinado separado antes. de forma simplificada, junto com função deixa confuso.
Sim, não senti dificuldade em entender pois trabalho bastante com funções. O fato de que teve bastante informação para apenas uma aula foi o que deixou alguns confusos, mas sem dúvidas uma parte || desse vídeo seria bastante esclarecedor.
A aula é ótima de entender para quem está aqui desde as primeiras aulas, mas claramente quem caiu de paraquedas vai ficar boiando. Vejam as aulas anteriores pessoal!
Ao assistir essa aula o x me retornou "você ta perdido".. mano do ceú..
foda bixo, dessa vez nao deu pra entender muita coisa
Não consegui entender :/
ficou complicado de entender bem confuso
Confesso que não entendi absolutamente nada dessa aula :(
Foda-se
:)
Bom saber q ue não sou o unico
Eu também:(
oooooooooooooo
printf("
Aula excelente....pqp
");
Eu acho que o pessoal não entendeu quando ele trocou o nome do parâmetro q vai na estrutura, usando apenas 'x', consideraram mt informação. Extrapolou o limite kkkkkkkkkkkkkkkkk e talvez n tenham entendido a funcionalidade do ponto q capta o membro de um objeto.
Eu n digo nd. Cheguei a aula 42 em poucas horas, só pulando... eu sou muito burro. Tenho que ficar revendo o básico sempre. A lógica do vídeo tá fácil te entender. Mas uma coisa é verdade: se você não praticar, não aprende nunca. Aprendi struct essa semana, mas há mt tempo insisto nisso. Coisa de anos em programação. Já desisti mts vzs.
faz muitas coisas desnecessárias que confundem a aula, poderia simplificar mais.
#include
#include
struct cotacao
{
float pt1;
float pt2;
float pt3;
};//Passei para fora do main para evitar erro!
int main(int argc, char *argv[])
{
float p,s,t,T=0;
printf("
\tPrimeiro teste:\t"); scanf("%f",&p);
printf("
\tSegundo teste:\t"); scanf("%f",&s);
printf("
\tTrabalho:\t"); scanf("%f",&t);
struct cotacao final (struct cotacao x);
struct cotacao CII;
CII.pt1 = 0.50*p;
CII.pt2 = 0.50*s;
CII.pt3 = 0.25*t;
T = CII.pt1+CII.pt2+CII.pt3;
struct cotacao realC;
realC.pt1 = CII.pt1*2;
realC.pt2 = CII.pt2*2;
realC.pt3 = CII.pt3/0.25;
printf("
\tPrimeira nota=%f
\tSegunda nota=%f
\tTerceira nota=%f
\tMedia=%f",CII.pt1, CII.pt2, CII.pt3, T);
printf("
\tValores reais:
");
printf("
\tPrimeira nota=%f
\tSegunda nota=%f
\tTerceira nota=%f
\t", realC.pt1, realC.pt2, realC.pt3);
printf("
\tBonus:
");
struct cotacao real;
printf("
\tAntes:
\tPrimeira nota=%f
\tSegunda nota=%f
\tTerceira nota=%f",
real.pt1,
real.pt2,
real.pt3
);
final (real);//depois, kkk
return 0;
}
struct cotacao final (struct cotacao x)
{
x.pt1 = x.pt1 *0.50+1;
x.pt2 = x.pt2 *0.50+1;
x.pt3 = x.pt3 *0.25+1;
printf("
\tDepois:
\tPrimeira nota=%f
\tSegunda nota=%f
\tTerceira nota=%f",
x.pt1,
x.pt2,
x.pt3
);
Também deu certo! Obrigado!
Não entendi nada... pro meu alívio, pelo visto, não fui só eu que não entendeu, rs.
nah, eu sou uma porta
aula confusa
Variáveis globais não é boa pratica de programação! Deve-se usar ponteiros para fazer esse programa corretamente.
+Thiago Teles ele montou esse curso abrangendo a maioria dos assuntos necessários para a programação, mas o curso funciona de modo que ele só dá exemplos com assuntos que ele já ensinou. Como ele ainda não ensinou ponteiros nas aulas anteriores, provável que seja o motivo de ele não ter usado.
eu nao entendi nada kkkkkk
Entendi absolutamente nada do que você fez!
cara, esse assunto é o pior assunto em c
Num é pior que ponteiro nem fodendo :x (Estou respondendo levando em consideração que você ainda não morreu e está viva e feliz).