== Douplus ==

Pelo visto trata-se de um Windows... Dê uma olhada em _execlp P.S.: A MSDN está sempre mudando os links, se este estiver quebrado use o Google.

Boa noite, gente. Eu estou precisando criar um meio de unir online um grupo de pessoas que participam de um projeto social. Fico pensando em algo bem opensource que permita facilitar o contato da galera. Eu comecei bolando um site do zero com alguns recursos que eu gostaria como: calendário de eventos, registro de usuários e grupos, email em massa e espaço para postagem. Mas fiz tudo isso meio sem projetar antes. Como é algo que várias pessoas vão usar e vai precisar sempre ser continuado, pensei se não sería mais interessante partir de algo já existente, como o Joomla ou o WordPress, porque ainda tenho vontade de integrar um fórum, criar um espaço para compartilhar documentos, e já deve ter ferramente pra tudo isso pela net. Baixei tanto o WordPress quanto o joomla, achei o Wordpress um tanto limitado por ser feito para blogs, e o Joomla! achei muito bugado (hahah) e sinto que usando ele não vou ter todo o domínio que eu gostaria sobre os recursos disponíveis. É muito inviável eu continuar o site que comecei do zero? Mesmo porque é a primeira vez que mexi com BD, tenho medo de estar fazendo algo errado. Será que tou brisando em querer fazer um site? Usar algo como um blog já bastaria? Criar algo no Facebook? Seilá, tou querendo fazer isso mas tou começando a ficar meio perdido. Eu tou gostando do que eu comecei a fazer do zero porque está me dando muita liberdade para criar além de eu conseguir deixar mais personalizado. Mas tam muita coisa que eu ainda quero colocar e não sei se vou me perder no caminho... Alguém já fez algo parecido ou tem uma idéia? Grato.

Fiz isso aqui e funcionou. Qual é o erro que está acontecendo aí? Vê se ajuda: http://scriptbrasil.com.br/forum/index.php?showtopic=147505

Faltou o DJGPP...

Vou tentar ajudar a pensar, não julgue nada do que eu disser como uma conclusão definitiva já que, como você, estou aprendendo. Tento levar essa questão mais para a discussão de sistemas operacionais do que características intrínsecas à linguagem. Para um SO de propósito geral (ex.: Windows, Linux), os processos são carregados na memória primária a partir de especificações contidas no cabeçalho dos arquivos executáveis. Essas informações definem o segmento de dados, o de texto (código), a área de pilha e a de heap (alocações em runtime). Estes trechos de código que você escreveu aí em momento algum lida com alocação dinâmica (malloc ou new), esses dados, em runtime, provavelmente estão na área libberada pelo o SO para o armazenamento de dados e não no heap. Desse modo esses vetores são tratados com as mesmas regras das variáveis. Veja um teste que fiz no debugger GDB usando um executável gerado por um código C que compilei com o gcc (GCC) 4.4.4: CÓDIGO: #include <stdlib.h> int main(void) { int *ptr1= (int *) (int [5]) {1, 2, 3, 4, 5}; int b = 123; int *ptr2 = (int *)malloc(sizeof(int)); return 0; } TESTE: (gdb) break main Breakpoint 1 at 0x4004f4: file ptrvet.c, line 5. (gdb) s The program is not being run. (gdb) r Starting program: /home/douplus/scriptbrasil/ptrvet Breakpoint 1, main () at ptrvet.c:5 (gdb) s (gdb) s (gdb) s (gdb) p ptr1 $1 = (int *) 0x7fffffffdda0 (gdb) p ptr2 $2 = (int *) 0x601010 (gdb) p b $3 = 123 (gdb) p &b $4 = (int *) 0x7fffffffddc4 (gdb) Repare como &b tem o endereço: 0x7fffffffddc4 que é próximo ao endereço apontado por ptr1 (0x7fffffffdda0) que pertencem ao segmento de dados. Já ptr2 aponta para uma memórica alocada dinâmicamente cujo endereço é 0x601010. Este segmento de memória primária é claramente outro, pertence ao heap. Pensando agora em características do C / C++, a "vida" das variáveis (não estáticas e não alocadas dinamicamente) é determinada por escopos. Por tanto, pela lógica, você trabalharía com esses vetores sem risco de acesso indevido enquanto você permanecer no escopo em que os definiu. Agora, se você tem em mente definir e trabalhar com esses vetores em uma função e retornar um ponteiro para eles, você corre sério risco de acesso indevido, pois é como trabalhar com uma variável definida em outro escopo, coisa que o C não permite. Fato, se você tentar criar uma função que retorne um ponteiro para uma variável definida dentro de seu escopo, o compilador acusa erro, para fazer isso usa-se alocação dinâmica e em alguns casos variáveis static. Por fim, algo que penso: nunca vejo o fato da linguagem C ser "excessivamente permissiva" como um problema, cabe ao programador saber ao máximo sobre os recursos da máquina, além de ter domínio sobre a linguagem que está usando e conhecer, pelo menos em teoria, a forma como o sistema operacional em questão está gerenciando os recursos da máquina.

Isso aqui tá dando erro de segmentação: for (i = 0; i < l; i++) { for (j = 0; j < c; j++) { fscanf(arq, "%d", mat[i][j]); printf("leu %d\n", mat[i][j]); } } Coloque um & antes do mat[j] no scanf(), para que seja passado o endereço de memória que deve armazenar o valor lido: for (i = 0; i < l; i++) { for (j = 0; j < c; j++) { fscanf(arq, "%d", &(mat[i][j])); printf("leu %d\n", mat[i][j]); } } E tome o cuidado de, sempre que você alocar memória a partir de variáveis pré-existentes, não alterar essas variáveis. Se não me engano um compilador C++ forçaria você a declarar l e c como constantes. Outro modo de fazer matrizes com valores obtidos em runtime é com a alocação dinâmica, o que deixaria o código assim: (...) int main (void) { int l, c, soma = 0; int i, j; FILE *arq = fopen("matriz.mtz", "r"); int **mat; fscanf(arq, "%d %d", &l, &c); mat = (int **)malloc(sizeof(int *) * l); /* Aloca o espaço para as linhas... */ for (i = 0; i < l; i++) { mat[i] = (int *)malloc(sizeof(int) * c); /* Aloca, dentro de cada linha, o espaço para as colunas. */ for (j = 0; j < c; j++) { fscanf(arq, "%d", &(mat[i][j])); printf("leu %d\n", mat[i][j]); } } fclose(arq); (...)

Olá! Eu já tinha visto este problema há muito tempo, na época não conseguí resolver também. mas agora dei uma olhadela e me pareceu simples... Posso estar enganado mas pensei nisso: [EDIT] Fiz um .gif pra mostrar o que pensei, mas acho que o tamanho em pixels ficou grande pra aparecer no fórum. Eis o link: http://img708.imageshack.us/i/dobraduras.gif/ [/EDIT] Veja se faz sentido, teste com um papel de verdade heheh. Abraço!

Por que você quer aprender C#?

Olá! O seguinte se passa comigo: estou fazendo um programa que lê e grava um vetor num arquivo. Em tal parte desse programa, eu preciso que ele faça uma pesquisa dentro desse vetor e pensei em usar os bons métodos da stl com std::vector. Acontece que estou manipulando o arquivo de forma binária e a função membro write da [n]fstream não aceita std::vector. Alguém sabe se é possível essa interação? Retirado de http://www.cppreference.com/cppio/write.html Grato pela atenção, Douplus.

size_t fread( void *buffer, size_t size, size_t num, FILE *stream ); int fseek ( FILE * stream, long int offset, int origin ); Olá, Fabio! Desculpa, hoje não tou pra didática... Acho que assim dá certo: #include <stdio.h> #include <stdlib.h> #include <string.h> int main () { char c[2]; int n = 0; FILE *pFile = fopen ("ArquivoTexto.txt", "r"); short comentarioAbertoC = 0, comentarioAbertoCPP; if (pFile != NULL) { while (fread(c, sizeof(char), 2, pFile) == 2) {//printf("%c %c\n", c[0], c[1]); if (c[0] == '/') { switch (c[1]) { case '/': if (comentarioAbertoC || comentarioAbertoCPP) { ++n; comentarioAbertoCPP = 1; } break; case '*': if (comentarioAbertoC || comentarioAbertoCPP) { ++n; comentarioAbertoC = 1; } } } else if (c[0] == '*') { switch (c[1]) { case '/': if (comentarioAbertoC != 0) comentarioAbertoC = 0; break; case '\n': if (comentarioAbertoCPP != 0) comentarioAbertoCPP = 0; } } fseek(pFile, -1, SEEK_CUR); } fclose(pFile); printf("Numero de Comentarios = %d.\n", n); } system("PAUSE>>null"); return 0; // 1º Comentário // 2º Comentário // 3º Comentário // 4º Comentário /* 5º Comentário */ // 6º Comentário }

Retornar mais de uma variável? Não tem como. Você pode retornar um array se as variáveis forem do mesmo tipo, ou retornar uma struct, ou ainda passar parâmetros por referência, assim você não os retorna mas as variáveis passadas para a função mantém seu valor caso alteradas. O comando break para funções é return .

Douglas? Eu? Assembly? Não? Mas acho que entendí por que você disse isso... Eu tinha escrito "pilha" sem querer num comentário, foi isso?

Se eu entendí bem, o que o bake quer é inserir e remover elementos da lista que está na RAM, depois que ela foi carregada... Não deixou a entender que queria atualizar o arquivo. A função de inserção no início já está implementada no código que você postou. Enquanto as funções de inserção nas demais posições você vai precisar de uma repetição que acontece até que a posição que se deseja seja encontrada. Se o elemento procurado for o último, a condição da repetição é semelhante a esta: while (aux->next != NULL) { aux = aux->prox; } // deixando [i]aux[/i] apontando para o último nó da lista. Alternativamente, você pode fazer a função de inserção ser recursiva ao invés de usar o while, a função chamará a sí mesma passando como parâmetro o próximo nó da lista enquando seu ponteiro prox apontar para algo diferente da condição de repetição. Finalmente, a inserção pode ser feita com: tlista *aux2; aux2 = (tlista *)malloc(sizeof(tlista)); aux2->prox = aux->prox; aux2->n = numeroDesejado; aux->prox = aux2; Enquanto às remoções: // REMOÇÃO NO MEIO E NO FIM DA LISTA: // aux é ponteiro para uma posição imediatamente antes da posição do elemento a ser retirado aux2 = aux->prox; // aux2 = nó a ser retirado aux->next = aux2->prox; // remove o nó free(aux); // REMOÇÃO NO COMEÇO DA LISTA: aux = ponteiroDaLista; // sendo ponteiroDaLista o ponteiro para o primeiro elemento da lista ponteiroDaLista = ponteiroDaLista->prox; // retira o elemento free(aux); // libera a memória do elemento retirado A busca por um elemento através de seu índice pode ser feita de modo similar ao que mostrei para inserção. Céus, espero que não tenha ficado confuso!

O : após uma declaração de variável em uma struct informa a quantidade de bits que se deseja para o tamanho da variável. Daí a fórmula 2^N-1, a partir do número de arranjos com repetição possíveis de 2 em grupos de N: Ar(2,5) = 2^N Considerando a representação do zero, o maior valor representável com N bits : 2^N - 1 No código que eu postei usei N = 3, logo o maior valor representável é: (111)b = (7)d = 2^3 - 1

O valor máximo é uma potência de dois? Se for tem um jeito prático, testa esse código: #include <stdio.h> typedef struct { unsigned int num : 3; // Valor máximo no caso é (2^3 - 1) } UINT; int main(void) { UINT var; int i; for (i = 0; i < 32; i++) printf("%d", var.num++); printf("\n"); return 0; } Até mais!

Não dá pra saber, o programa pronto depende de detalhes do desenvolvedor. Por exemplo, você quer que o programa mostre uma mensagem de erro se o usuário introduzir um número que não tenha dígitos? Como vai armazenar a entrada? Vai separar os algarísmos em instruções diferentes, vai usar uma função recursiva ou um um laço de repetição? O loop será pré-teste ou pós -teste? A string de saída será feita durante o processo de separação ou depois? A string de saída será feita com um switch ou a partir de um array com o nome das casas do número?. Tem que pensar, amigo... Não há uma única possibilidade de projeto, portanto não há uma única solução e portanto não há como dizer como ficaria O programa pornto. Poderíamos fazer um programa pra você (e talvez até cobrar por isso) se fosse esse o objetivo desse fórum, e o seu programa pronto, com a sua maneira de resolver, nunca vai existir a menos que você faça. Simbora, ânimo! Começa analisando o problema:: Dividindo-o em problemas menores: 1-) Receber um número de 3 algarísmos 2-) Separar os algarísmos 3-) Montar a string de saída 4-) Mostrar a string na tela Agora pensa como vai ficar a main() int main(void) { // Declaração de variáveis // Problema 1: Ler entrada // Problema 2: Separar os algarísmos // Problema 3: montar a string // Problema 4: mostrar a string na tela return 0; } E agora é só começar a resolver... Para o problema 1 o Jonathan sugeriu que o programa recebêsse a entrada com uma string: Pensa na sua função main() int main(void) { // Declaração de variáveis char numero[3]; char *extenso; // Aqui pode se armazenar o número por extenso // ... // mais variáveis?... // Problema 1: Ler entrada printf("Digite um inumero de 3 algarismos: "); scanf("%s", &numero); // Problema 2: Separar os algarísmos // A idéia do Jonathan de ler o número como string já faz com que os algarismos fiquem separados // Problema 3: montar a string // Um loop com 3 repetições? // ... // Problema 4: mostrar a string na tela printf("Numero por extenso: %s", extenso); return 0; } ... e por aí vai! P.S.: É claro que você vai fazer o programa usando só o que você já sabe, o seu conhecimento também define o programa final. Outras pessoas conhecem outras coisas implementarão soluções diferentes.

Hihihih.. É só formatar direitinho no editor que faz sentido :-) É que eu tava sem nada pra fazer sexta à noite e resolví fazer um jogo da cobrinha literalmente da noite para o dia, só para passar o tempo, sem comprometimento, por isso deixei os levels na RAM mesmo. Porém, acabei gastando mais tempo porque nunca tinha mexido com OpenGL. Agora eu já estou "nos finalmentes'", mas o jeito que a OpenGL funciona me fez mudar todo o código todo e perder a lógica inicial. Se você quiser conversar eu já vou montando meu formulário de questões aqui... Ahah! P.S.: Rí demais do seu avatar.

A verdade é que eu estou fazendo um joguinho da cobrinha por diversão e queria uma função que recebe o número do level e retorna o mapa (onde tem as paredes). Tá ficando alguma coisa assim (acho que se exemplificar você entende melhor :-): Stage *loadstage(short num) { static Stage stageVec[3] = { { { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 } }, { { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 } }, { { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }, { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 } } }; return ((num < LEVELS) ? (stageVec + num) : NULL); }

Sim, isso deu certo, tou usando o gcc version 4.3.3 (GCC). Eu queria que fosse uma matriz estática mesmo, não quero que realoque toda vez que chame a função. Eu descobrí um macete para dar certo, mas é bem estranho... Consiste em definir o int[3][3] ou int[3] como um novo tipo: #include <stdio.h> typedef int mask[3]; mask *retarray(void) { static mask tridmat[3][3] = { { { 3, 6, 9 } }, { { 12, 15, 18 } }, { { 21, 24, 27 } } }; printf("%d\n", tridmat[0][0][0]); return tridmat[0]; } int main(void) { mask *tridmat; tridmat = retarray(); printf("%d\n", tridmat[0][0]); return 0; } Parece que uma função em C++ só retorna ponteiros e não arrays... Estranhíssimo, mas funciona. Obrigado e qualquer nova informação poste aí!

Três questões: 1-) Por que isso dá certo? #include <stdio.h> char **retarray(void) { static char *abra[3][10] = { { "abra", "kadabra", "alakazam" }, { "bulbasaur", "ivysaur", "venusaur" }, { "um", "dois", "tres", "quatro" } }; printf("%s\n", abra[0][0]); return abra[0]; } int main(void) { char **str; str = retarray(); printf("%s\n", str[0]); return 0; } 2-) Por que isso dá errado? #include <stdio.h> int **retarray(void) { static int *tridmat[3][10] = { { { 3, 6, 9 } }, { { 12, 15, 18 } }, { { 21, 24, 27 } } }; printf("%d\n", tridmat[0][0][0]); return tridmat[0]; } int main(void) { int **tridmat; tridmat = retarray(); printf("%s\n", tridmat[0][0]); return 0; } 3-) E, finalmente, por que isso dá errado? #include <stdio.h> int **retarray(void) { static int tridmat[3][3][10] = { { { 3, 6, 9 } }, { { 12, 15, 18 } }, { { 21, 24, 27 } } }; printf("%d\n", tridmat[0][0][0]); return tridmat[0]; } int main(void) { int **tridmat; tridmat = retarray(); printf("%s\n", tridmat[0][0]); return 0; }

Tudo depende, né? Quanto é a remuneração?

Boa noite, Minduca! Também nunca implementei uma tabela hash embora já tenha lido a respeito várias vezes. Então pau na máquina! Ok. Faça uma função de hash que receba como parâmetro o tipo de dados que você quer associar a chave (a chave no caso é int, né?) Você pode fazer a função de inclusão chamar a função hash, ou pode chamar a função hash e passar a chave para a função de inclusão. Pensei assim: struct entrada_hash { /* representação da entrada */ int chave; void *info; struct EntradaHash **ant; struct EntradaHash **prox; struct EntradaHash *duplicatas; /* lista de duplicatas */ }; typedef struct entrada_hash EntradaHash; typedef struct tab_hash { EntradaHash *rootPtr, *primeiraEntrada, *ultimaEntrada; const unsigned int tamanho; } TabelaHash; TabelaHash criar(const int tamanho); /* cria a tabela, tamanho indica quantas entradas pode receber inicialmente */ EntradaHash *inserir(const int c, void *i); EntradaHash *TabelaHash buscar(TabelaHash *th, EntradaHash i); EntradaHash *remover(TabelaHash*th, const int c); int hash(void *i, const int numDeBytes); /* função hash */ void *redimensionar(TabelaHash *th, const int tamanho); /* redimensiona a tabela, pode ser chamada também por inserir() */ Observações: 1-) optei por usar ponteiro para void porque não seiqual tipo de dados quer associar com as chaves, desse modo um ponteiro genérico (void *) para a variável é armazenado; 2-) essas estruturas que definí para a tabela hash são variações das suas usadas para a lista. Na estrutura EntradaHash acrescentei uma lista de duplicatas, se não tiver nenhuma o ponteiro deve apontar para NULL. È de quebrar um pouco a cabeça, para fazer tudo isso pensei que a tabela hash é um multimap (em C++ daria pra usar STL) e desenvolví um pouco. Boa sorte, e quaisquer progressos ou problemas, posta aí por favor! Até mais!

Tá certo, despertou minha curiosidade! Você diz que tem um programa que detecta executáveis maliciosos nas máquinas clientes. Mas, como você diz também, esse programa está no servidor, como então ele detecta aplicativos executados no cliente? Seria então um aplicativo executado no cliente? Não entendo muito de programação para Windows, mas já brinquei com funções da API relacionadas a processos, com certeza se você futucar a msdn ela escarra alguma coisa de útil. Mas, bem... Como sou curioso já dei uma fuçada: http://msdn.microsoft.com/en-us/library/ms...v=VS.85%29.aspx Tou sem tempo de ver essas coisas agora, mas qualquer prograsso, poste aí!

Uma coisa... O número 1 não é primo. Por definição um número é primo se é divisível exatamente por dois números. Seu programa informa que 1 é primo porque a condição inicial do loop já retorna falsee aux permanece 1.

Isso é normal! O objeto destruído é o que foi usado pra cópia enão o ooo->item Fiz umas alterações e um programa de teste pra ver se esclarece: #include <iostream> using std::cout; using std::endl; // Para teste: typedef int area; typedef int SDL_Surface; template <class T> struct lista_ligada { lista_ligada(T info) { item = info; l = NULL; } T item; lista_ligada<T>* l; }; class opcao { public : area* Area; //Área da tela onde está a opção. public : opcao* Baixo; //Para qual opção irá ao ser pressionado para baixo. public : opcao* Cima; //Para qual opção irá ao ser pressionado para cima. public : opcao* Esquerda; //Para qual opção irá ao ser pressionado para a esquerda. public : opcao* Direita; //Para qual opção irá ao ser pressionado para a direita. //Para alinhar o highlight à área. public : int offset_x; public : int offset_y; public : SDL_Surface* highlight_img; //Imagem que circundará a opção em highlight; public : opcao(void) { cout<<"opcao(void)"<<endl; } public : opcao(area* ax, SDL_Surface* h, int offx, int offy) { Area = ax; highlight_img = h; offset_x = offx; offset_y = offy; Baixo = NULL; Cima = NULL; Esquerda = NULL; Direita = NULL; cout<<"opcao(area *, SDL_Surface *, int, int)"<<endl; } ~opcao() { cout<<"~opcao()"<<endl; } }; class Teste { public: Teste(void) : ooo(NULL) { } opcao* NovaOpcao(area* ax, SDL_Surface* h, int offx, int offy) { opcao* r; if (ooo == NULL) //Primeira área a ser adicionada. { ooo = new lista_ligada<opcao>(opcao(ax, h, offx, offy)); // Essa linhas saem: // ooo->item = opcao(ax, h, offx, offy); // ooo->l = NULL; qtde = 1; //ColocaFoco(&(ooo->item)); foco = &(ooo->item); r = &(ooo->item); } else { lista_ligada<opcao>* ppp = ooo; while (ppp->l != NULL) { ppp = ppp->l; } ppp->l = new lista_ligada<opcao>(opcao(ax, h, offx, offy)); //<-- não FUNCIONA // Essas tmabém: //ppp->l->item = opcao(ax, h, offx, offy); //ppp->l->l = NULL; qtde++; r = &(ppp->l->item); } return r; } protected: lista_ligada<opcao> *ooo; private: int qtde; opcao *foco; }; int main(void) { Teste teste; area ar = 1; SDL_Surface surf = 2; opcao *optr = teste.NovaOpcao(&surf, &ar, 2, 3); cout<<"Area = "<<(*(optr->Area)) <<"\nHighlight IMG: "<<(*(optr->highlight_img)) <<"\nx = "<<optr->offset_x<<"\ny = "<<optr->offset_y<<endl; return 0; } Saída: $ ./durub3 opcao(area *, SDL_Surface *, int, int) opcao(void) ~opcao() Area = 2 Highlight IMG: 1 x = 2 y = 3 $ Repare que as variáveis de opcao da lista alocada continuam intáctas e não dão erro de memória porque não foram destruídas. Usei o GDB para analizar as chamadas de construtores e destruidores: (gdb) r Starting program: /home/douplus/ajudas/durub3 Breakpoint 1, main () at durub3.cpp:97 97 Teste teste; (gdb) s Teste (this=0xbfa05b98) at durub3.cpp:52 52 Teste(void) : ooo(NULL) { } (gdb) main () at durub3.cpp:98 98 area ar = 1; (gdb) 99 SDL_Surface surf = 2; (gdb) 101 opcao *optr = teste.NovaOpcao(&surf, &ar, 2, 3); (gdb) Teste::NovaOpcao (this=0xbfa05b98, ax=0xbfa05b90, h=0xbfa05b94, offx=2, offy=3) at durub3.cpp:57 57 if (ooo == NULL) //Primeira área a ser adicionada. (gdb) 59 ooo = new lista_ligada<opcao>(opcao(ax, h, offx, offy)); (gdb) opcao (this=0xbfa05b08, ax=0xbfa05b90, h=0xbfa05b94, offx=2, offy=3) at durub3.cpp:35 35 Area = ax; (gdb) 36 highlight_img = h; (gdb) 38 offset_x = offx; (gdb) 39 offset_y = offy; (gdb) 41 Baixo = NULL; (gdb) 42 Cima = NULL; (gdb) 43 Esquerda = NULL; (gdb) 44 Direita = NULL; (gdb) 45 cout<<"opcao(area *, SDL_Surface *, int, int)"<<endl; (gdb) opcao(area *, SDL_Surface *, int, int) 46 } (gdb) lista_ligada (this=0x804a008, info= {Area = 0xbfa05b08, Baixo = 0xb7fa77f0, Cima = 0xb7f20fc7, Esquerda = 0x3df6174, Direita = 0xb7fe9ff4, offset_x = 134513120, offset_y = -1208048024, highlight_img = 0xbfa05b08}) at durub3.cpp:12 12 lista_ligada(T info) { item = info; l = NULL; } (gdb) opcao (this=0x804a008) at durub3.cpp:32 32 public : opcao(void) { cout<<"opcao(void)"<<endl; } (gdb) opcao(void) ~opcao (this=0xbfa05b08) at durub3.cpp:47 47 ~opcao() { cout<<"~opcao()"<<endl; } (gdb) ~opcao() Teste::NovaOpcao (this=0xbfa05b98, ax=0xbfa05b90, h=0xbfa05b94, offx=2, offy=3) at durub3.cpp:63 63 qtde = 1; (gdb) 66 foco = &(ooo->item); (gdb) 68 r = &(ooo->item); (gdb) 86 return r; (gdb) 87 } (gdb) main () at durub3.cpp:105 105 <<"\nx = "<<optr->offset_x<<"\ny = "<<optr->offset_y<<endl; (gdb) Area = 2 Highlight IMG: 1 x = 2 y = 3 106 return 0; (gdb) 107 } (gdb) 0xb7d426a5 in __libc_start_main () from /lib/libc.so.6 (gdb) Single stepping until exit from function __libc_start_main, which has no line number information. Program exited normally. (gdb) O que aconteceu foi: 1) linha 101 cria uma opção; 2) linha 59 cria lista de opcao; 59 ooo = new lista_ligada<opcao>(opcao(ax, h, offx, offy)); 3) construtor opcao(area *, SDL_Surface *, int, int) chamado; 4) construtor de lista_ligada chamado; 5) construtor de lista_ligada por sua vez chama construtor opcao(void); 6) (opcao(ax, h, offx, offy)) da linha 59 foi copiado para ooo->item[]b/; 7) destruidor ~opcao() chamado para destruir (opcao(ax, h, offx, offy)) na linha 59; 8) Não foi chamado o destruidor de ooo->item; CONCLUSÃO: ooo->item não foi destruído! Pode usá-lo.