Jonas de Abreu

Esta faltando parenteses no seu if. Precisa colocar mais um logo depois do if e um no final da linha. Outra coisa, voce declarou todas as variaveis como int, mas voce esta usando turno como um char. é melhor declara-la como char. O mesmo vala para catg. Mais uma coisa, getch() não é padrão ANSI. De preferencia para getchar() da stdio.h que é padrão ANSI e tem comportamento semelhante.

Voce esta falando da CUI do X.org? Eles provavelmente usam ncurses ou python pra fazer a interface. Na maioria das distros linux já vem com ncurses instalado. Voce demora uma tarde pra aprender a usar o ncurses pra fazer coisinhas basicas. é razoavelmente simples. de uma olhada em http://www.gnu.org/software/ncurses/ pra saber mais.

Esse é um erro comum pra quem está comecando. Uma string é na verdade um vetor de caracteres. Por isso, o operador == não funciona. (ele so funciona para tipos primitivos). Se voce quer comparar strings, voce pode usar a funcao strcmp da lib string.h . Ela devolve 0 se as strings forem iguais, >0 se string a > que string b e < caso contrario. #include <stdio.h> #include <string.h> int main(){ if (strcmp("Ola", "ola") == 0) printf("Isso não deveria ter sido impresso\n"); else printf("Isso deveria ter sido impresso\n"); return 0; } E estou achando estranho o uso do getch() (que não é das bibliotecas padrão ANSI de C. de preferencia para getchar() ). Ali onde ele esta sendo usado, ele vai ler o primeiro caractere da senha que o usuario passar e iria deixa-lo em senha, que sera sobrescrita depois com o resto da senha. Voce perderia o primeiro caractere. Mas isso nem vai compilar direito, porque voce esta tentando colocar um char em um tipo char *, o que vai pelo menos gerar um Warning e não faz muito sentido.

Digamos que a sua struct foi criada desta forma: typedef struct _foo{ int i; double d; } foo; para passar como parametro para uma funcao voce faz como voce faria com qualquer outro tipo: void foo_function(foo f){ /*seu codigo aqui*/ } caso voce queira modificar uma struct dentro de uma funcao, voce deve passar um ponteiro para a funcao: void foo_function(foo *f){ /*seu codigo aqui*/ }

Se voce esta usando um ponteiro de char para representar uma matriz, recomendo usar a funcao strcpy da string.h, porque ela copiaria todo o conteudo e não apenas o primeiro caractere como faz o codigo do felipe. Caso queira copiar memoria de um ponteiro que não esteja representando uma string, use memcpy da string.h. Mais uma coisa, result não tem o valor "+". Result aponta para o valor "+", que escrito dessa forma é uma string com apenas um caractere (mais o ' \ 0').

Se voce esta procurando C um pouco mais avancado, mantenho um tutorial de C em http://www.vidageek.net. Procure por Dia C la.

cara, ve na especificacao do que voce esta tentando compilar o que ele precisa pra compilar (dependencias). não adinata so encontrar o header. Voce precisa instalar a lib associada a esse header. Sem contar que encontrar um header pelo nome é uma tarefa bem chata.

Das duas uma. Ou voce esqueceu de incluir o header referente as funcoes que voce usa e que estao dando problema ou esta faltando alguma lib.

Olha, voce não vai encontrar uma copia (para download) do Microsoft C que não seja pirata. Se voce precisa de um compilador C, recomendo o GCC, melhor compilador OpenSource para C. http://gcc.gnu.org . O GCC, ainda é muito melhor do que a maioria de compiladores proprietarios.

Falha de segmentacao? Tente colocar o codigo aqui pra gente ter pelo menos um ponto de partida.

Existe um projeto opensource de sistemas de telefonia sobre IP (VoIP e mais um monte de coisa). Provavelmente voce encontrara na documentacao do sistema deles algo referente ao assunto. é uma questao de baixar o codigo fonte e a documentacao e procurar a area onde isso é feito. O projeto fica em http://www.asterisk.org .

Voce pode usar um analizador lexico como o yacc ou flex. é um pouco chato de aprender no comeco, mas depois voce acostuma.

cara, coloque o seu codigo entre tags [ code ] e [ /code ], mas sem o espaco. Assim fica mais facil pra gente analizar o seu codigo.

Oi Heldinho, Talvez seja bom voce licenciar o seu codigo sob a licenca LGPL de software livre. Ela garante o que voce quer (que as pessoas possam usar o seu codigo a vontade e para qualquer fim) e voce estara contribuindo para o crescimento do software livre. o Site que explica a LGPL é: http://www.gnu.org/licenses/lgpl.html

Cara, entra no site http://www.ime.usp.br/~pf/algoritmos/aulas/quick.html que é de um dos melhores professores do IME-USP. La ele ensina não apenas o quicksort, mas diversos outros algoritmos.

Para definir a funcao, basta voce colocar o seguinte codigo antes do lugar onde ela for usada (e fora de outras funcoes). No caso da funcao fatorial: double fat(int n){ if (n == 0) return 1.0; return n*fat(n-1); }

Mas porque voce esta usando um segundo contador para contar o numero de b? O numero de letras que serao alteradas esta em contador, pois voce ira alterar o apenas as letras 'a'. Portanto voce deve imprimir o valor de contador e não contador2. E mais uma coisa, o 'if' suporta bloco de comandos. Basta voce acrescentar um { no comeco do bloco e um } no fim do bloco. assim o seu codigo dentro do for ficaria assim: if (palavra[x] == 'a') { contador = contador + 1; palavra[x] = 'b'; }

Uma coisa, em C ou C++, os indices de vetor comecam no 0, portanto se voce tem 8 posicoes num vetor, voce pode acessar somente ate a posicao 7, ou vai dar falha de segmentacao (ou bus error em alguns casos). Para acessar o caractere de uma palavra do vetor, voce usa a mesma notacao que matriz: reservadas[1][1] vai te dar o caractere h, pois "Then" é o valor do indice 1 do vetor reservadas e h é o valor de indice 1 de Then. Quanto ao fato de não compilar, poste o erro e a parte de codigo apontada por ele. Dai a gente pode ajudar.

Acho que consegui pensar num jeito bem melhor: pidpai = getpid(); for (i = 0; i < 50; i++){ fork(); if (getpid() != pidpai) break; } assim voce garante a criacao dos 50 processos. Como pidpai é usada somente para leitura, não tem problema de sincronismo.

Este codigo que eu tinha colocado na compila. A ideia é ele servir de base pra voce escrever o seu codigo. Vou colocar detalhadamente o caminho que eu fiz pra chegar a esse codigo: Como é uma somatoria de N termos, achei mais facil calcular um termo por vez e soma-lo (ou subtrai-lo) de uma variavel que armazena o resultado. Chamei de i o indice do termo e dai olhei pra sequencia procurando um padrão de construcao: S = X - X2/3! + X4/5! - X6/7! + X8/!9 Tirando o primeiro termo (i = 0), os outros são formados dessa forma como uma funcao de i (Vou chamar de S o iesimo termo da sequencia): S[1] = (X^2)/3! = (X^(2*i))/(2*i + 1)! S[2] = (X^4)/5! = (X^(2*i))/(2*i + 1)! A partir desse ponto, assumi que todos os termos subsequentes vao ser da mesma forma, como funcao de i. (Eu já conhecia esta somatoria, mas voce prova por inducao que isso é verdade). em C, cada termo ficaria mais ou menos assim: S = pow(x, 2*i)/fatorial(2*i + 1); Faltava definir fatorial, mas já tinhamos feito isso no post #2, então onde escrevi a chamada para a funcao fatorial, podemos simplesmente a funcao fat. então: S = pow(x, 2*i)/fat(2*i + 1); Agora falta fazer um loop para calcular N termos Para o loop, eu notei que a gente pode simplificar a funcao se definirmos j como 2*i S[j/2] = pow(x, j)/fat(j+1); Note que a funcao é exatamente a mesma, apenas fiz uma troca de variaveis para facilitar o codigo. Como j = 2*i, quando queremos calcular o termo i, calculamos o termo j/2. então em um loop que ira calcular todas os termos, a nossa variavel que controla o termo sendo calculado sera incrementada de 2 ao invez de um (novamente porque j = 2*i) Para saber quando eu cheguei ao termo N, que é o ultimo a ser calculado, novamente me vali que j = 2*i. Se i deveria parar em N, j tem que parar em 2*N. Faltava apenas um pequeno detalhe: Existe uma alternancia de sinal entre os termos. De alguma forma eu preciso saber se eu devo somar ou subitrair do resultado este termo. Em S = X - X2/3! + X4/5! - X6/7! + X8/!9 - da pra notar que os termos impares devem ser subtraidos (estou contando o primeiro termo como sendo o termo zero) como a minha variavel é j (que é igual a 2*i), primeiro eu precisava tranformar j em i e depois ver se ele é impar. Como o resto da divisao de um numero impar por dois sempre resulta em 1, cheguei a seguinte condicao: ((j/2)%2 == 1) então montando o codigo, ficou assim: res = X; for (j = 2; j <= 2*n; j+=2){ if ((j/2)%2 == 1)/*o termo é impar*/ res = res - pow(x, j)/fat(j+1); else /*o termo é par*/ res = res + pow(x, j)/fat(j+1); } Como voce nota, a cada interacao do for o termo é calculado e ate o termo j/2 (termo i) a somatoria já esta na variavel res. Quando o laco termina, todos os termos já foram colocados na variavel res. Apenas mais um comentario. Como a nossa formula funciona apenas para os termos a partir do segundo (termo 1) , eu inicializo o resultado com o primeiro termo (termo 0) que é X. dai o laco calcula os outros (por isso ele comeca a partir de j = 2). Para mostrar o que acontece com o valor da variavel res, aqui vai um diagramazinho de cada interacao: Antes de comecar: res = X Valor de j | Valor de res 2 | X - X2/3! 4 | X - X2/3! + X4/5! 6 | X - X2/3! + X4/5! - X6/7! 8 | X - X2/3! + X4/5! - X6/7! + X8/!9 e assim por diante. Espero que eu tenha conseguido clarear o algoritmo para voce. Caso não entenda alguma coisa, não se preocupe e continue perguntando ate que tenha entendido. Faz parte do aprendizado.

Minha especialidade não é C++ e sim C, mas como a base das duas é a mesma e provavelmente o sistema de tratamento de erros tambem é o mesmo, vou explicar como funciona em C. Segmentation Fault (SegFault) é um erro meio generico que pode, dentre outros, significar que: - Houve um acesso a posicao invalida do vetor (pode gerar bus error se o vetor estiver na pilha) - Tentativa de acessar valor de ponteiro NULL - Tentativa de acessar valor de posicao de memoria fora de escopo (seu programa tentou acessar memoria que não foi alocada para seu programa) - Divisao por zero - Dezenas de outros erros que eu não lembro agora mas que eu já cometi.... então, se voce colocar parte do codigo fica mais facil de procurar o erro. Ou, se preperir, nesse site voce encontra algumas estrategias de depuracao: http://vidageek.net/2007/02/23/estrategias...epuracao-debug/ editado:broken link corrigido

Pelo que sei o fork() (lembro de uma especificacao do fork em uma shell, acredito que deva funcionar de forma semelhante) copia o processo atual e continua executando ele a partir de onde o anterior chamou o fork. então se voce colocar uma contadora global estatica com restricao de acesso (a generalizacao do algoritmo de Peterson para sincronismo de recursos da conta do recado) a apenas um processo, voce pode controlar o numero de filhos. static int nfilhos; int main(){ nfilhos = 0; comeco: PetersonCriticalSectionEnter();/*esta funcao não existe. Voce teria que implementa-la*/ if (nfilhos < 50){ nfilhos++; fork(); PetersonCriticalSectionLeave();/*o mesmo aqui*/ goto comeco;/*sei que goto é meio ruim, mas não consegui pensar em uma solucao melhor. While ia ser ruim pois o numero de filhos esta mudando de forma que o laco so quebraria depois de muito tempo*/ } PetersonCriticalSectionLeave(); return 0; } Apenas tome cuidado para não lançar processos demais (eu conheco a tentacao de criar mil processos de uma vez) pois o escalonador não vai conseguir aguentar e seu micro inteiro vai entrar em uma deadlock porque os processos não ficam tempo suficiente no processador para fazerem algo.

Acho que já estou entendendo o problema aqui. Voce provavelmente nunca programaou em uma linguagem estruturada como C. Vou então explicar uns conceitos basicos de C (e de diversas outras linguagens estruturadas): Em C, existem diversos tipos predefinidos (chamados tipos primitivos). são esses tipos que nos usamos para declarar variaveis ou criar estruturas mais complexas (usando struct). Alguns desses tipos: int (inteiro), float (ponto flutuante de precisao simples), double (ponto flutuante de precisao dupla), char (caractere), etc. C é uma linguagem com suporte nativo a funcoes. Uma funcao é um bloco de codigo que possui as seguintes propriedades: 1 - Possui um tipo de retorno (mesmo que seja void); 2 - Possui um nome (identificador); 3 - Pode ou não possuir parametros; 4 - é executado quando seu identificador é usado (na verdade o identificador de funcao é um ponteiro, mas não vamos entrar em detalhes) 5 - Pode ser definida pelo programador. Possui outras propriedades mas não vem ao caso. fat e pow são funcoes. A primeira recebe um inteiro como parametro e a segunda recebe dois double como parametros. A primeira voce pode usar a funcao que eu defini no post #2. A segunda já esta na biblioteca que voce esta incluindo (math.h). Essas funcoes funcionam do seguinte modo: Quando voce as chama (escreve o nome delas e coloca os parametros como eu fiz no post #8), elas vao executar o bloco de codigo delas (que fica depois da declaracao da funcao e entre { e } como voce pode ver no post #2) e colocar o resultado delas no mesmo lugar em que foram chamadas. Assim, ao invés de eu calcular o fatorial do numero colocando em uma variavel e depois usar a variavel para dividir, já divido pela funcao, sabendo que ela vai devolver o resultado e ele sera usado como uma variavel. O mesmo vale para o pow. O proprio main que voce declarou é uma funcao (que é chamada pelo inicializador do seu programa, algo que raramente precisamos mexer). Se tiver mais duvidas sobre funcoes ou structs que eu citei mais acima, abra um (ou quantos forem necessarios) novo tópico no forum e a gente discute la.

O segundo algoritmo do post dois calcula esta expansao de Taylor. Mas aqui vai um que é mais compreensivel, mas muito menos otimizado (dependendo da precisao ele pode levar muito mais tempo pra executar): int n; double x; double res = x; for (i = 2; i <= 2*n; i+= 2){ if ((i / 2) % 2 == 1)/*controla o sinal da parcela*/ res += pow(x, i)/fat(i+1); else res -= pow(x, i)/fat(i+1); } Para calcular o fatorial voce pode usar a funcao do post #2. Mas eu realmente aconselho voce a dar uma olhada na versao construtiva deste algoritmo (post #2). Aquela é uma estrategia geral pra calcular sequencias como essa de forma eficiente.

A utilizacao desses operadores seguem o seguinte principio: Em C, uma divisao de inteiros devolve um inteiro n tal que n é o maior inteiro que satizfaca n*k <= x, sendo x o numero que voce quer dividir por k. O operador % devolve o resto da divisao acima, ou seja, devolve r, tal que n*k + r = x. Isso é muito matematico e talvez voce não esteja entendendo lhufas. então vamos pra parte pratica: Quando fazemos uma divisao por uma potencia da base que estamos usando (no caso base 10) é o mesmo que extrair os primeiros digitos do numero: então:seja ABCD um numero de quatro digitos(que são A, B, C e D): ABCD / 100 = AB, pois AB*100 <= ABCD e AB é o maior pois CD nunca podera chegar a 100 na base 10. ABCD % 100 = CD, pois AB*100 + CD = ABCD. Com base em tudo isso, da pra voce ver que sempre que voce tiver 4 digitos e quiser extrair os dois primeiros voce simplesmente divide o numero por 100 e quando quiser os dois ultimos voce pega o resto da divisao por 100, ou seja, toma o modulo 100 do numero. Espero que isso tenha clareado um pouco pra voce.