Durub

Dependendo do que ele usar da conio.h (não li o código com detalhes), você vai precisar do C++ Builder. No mínimo, terá que linkar a biblioteca wsock32.lib no "compilador" de sua preferência. Abraços!

Bom, tem vários métodos: Você pode editar em um editor hexadecimal (como o Rafael falou) o nome do executável diretamente. Limitações: - O tamanho do nome do executável deve ser igual ou menor que "ragexe.exe" Você pode hookar uma função que use o ragexe.exe e substituir este valor lá. Exemplo: extern void injetarNoRag(char *ragexe); void hookedInjetarNoRag(char *ragexe) { injetarNoRag("MeuNomeDoExecutavel.exe"); } Limitações: - A função tem que existir. Você pode decompilar o executável/dll, trocando o tamanho e valor da variável que ele utiliza para guardar o "ragexe.exe". Limitações: - Nem sempre funciona (pois o decompilador pode produzir código que não seja usável, ou requere uma biblioteca desconhecida) Com certeza deve ter muitos outros métodos. Acho que terá que estudar um pouco para conseguir o que quer (se não for o primeiro método, esse é simples e qualquer um pode fazer). Abraços!

Realmente, escrevi bem rápido e lendo a documentação porcamente. Obrigado pelos avisos! Vou corrigir no meu post, se não houver problema. (e acho que não há!) Abraços!

É possível. Abraços.

Você pode usar algumas funções da time.h. Exemplo: (o nome estaria no filename); #include <stdio.h> #include <time.h> int main () { time_t rawtime; struct tm *timeinfo; char filename[128]; time (&rawtime); timeinfo = localtime (&rawtime); sprintf(filename, "dados.%d.%d.%d.bin", timeinfo->tm_mday, timeinfo->tm_mon, timeinfo->tm_year + 1900); return 0; } Abraços!

A pasta VNC e o arquivo ConfRegUser.txt existem? Abraços.

Sim, recomendo a biblioteca libCURL. http://curl.haxx.se/ Escrita em C, mas funciona no C++ sem problemas. Você também tem a vantagem de usar uma biblioteca muito conhecida pelos desenvolvedores. Abraços!

Headbanger, somente if's aceitam a expressão else após seu fechamento. while, for, etc. são apenas estruturas de repetição. Abraços.

Tem sim, pelo Qt Creator, ou você muda em uma propriedade do QButton, ou você pode usar CSS. Não estou com ele aqui instalado no momento, mas se precisar de ajuda, avise-me que instalo! Abraços!

Sem dúvida, Qt Framework. Abraços!

Abra um terminal: sudo apt-get install gcc g++ gdb Acho que isso é o que você precisa pra programar usando o CodeBlocks (compilação + debugging), mas não sei como funciona o debugging nele. No momento estou usando só o gedit, mesmo. (na verdade o "gmate") Abraços!

Parabéns, obrigado por compartilhar! Abraços!

Você deve usar %s ao invés de %c nos scanf, e quando é string (array de caracteres) não precisa e nem pode usar o & nesse caso. (ficaria um **char) Acho que nesta linha %j deve ser trocado por %d: printf("\n Nota: %j",j); Abraços!

Use um ponteiro para void. Exemplo de pilha (fiz a um bom tempo atrás, tem um bug na stack_contract) #include "stack.h" #include "mem.h" #include "assert.h" /* ALLOCATION */ stack_t *stack_alloc(int quantity) { stack_t *stack = stack_create(); assert(quantity); return stack_expand(stack, quantity); } stack_t *stack_create() { stack_t *stack = ALLOC(sizeof(stack_t)); stack->_top = NULL; stack->_stacked = 0; stack->_alloc = 0; return stack; } stack_t *stack_expand(stack_t *stack, int quantity) { int by_how_many = (quantity + stack->_alloc) * sizeof(ptr_t *); int factor; stack->_alloc += quantity; if(stack->_stacked != 0) { factor = stack->_stacked - 1; stack->_top = realloc(stack->_top - factor, by_how_many); stack->_top += factor; } else { stack->_top = realloc(stack->_top, by_how_many); } return stack; } stack_t *stack_contract(stack_t *stack) { return stack; /* not implemented correctly yet */ int by_how_many = stack->_stacked * sizeof(ptr_t *); stack->_alloc = stack->_stacked; stack->_top = realloc(stack->_top - stack->_stacked + 1, by_how_many); return stack; } void stack_free(stack_t **stack) { assert(*stack); if((*stack)->_top != NULL) { if((*stack)->_stacked != 0) { free((*stack)->_top - ((*stack)->_stacked - 1)); } else { free((*stack)->_top); } } FREE(*stack) } /* ELEMENTS */ void *stack_top(stack_t *stack) { return (void *) *(stack->_top); } void *stack_pop(stack_t *stack) { assert(stack->_stacked > 0); stack->_stacked--; if(stack->_stacked == 0) return (void *) *(stack->_top); else return (void *) *(stack->_top--); } void stack_push(stack_t *stack, void *value) { if(stack->_alloc <= stack->_stacked) { stack_expand(stack, STACK_EXPANSION_FACTOR); } if(stack->_stacked++ > 0) { stack->_top++; } *(stack->_top) = (ptr_t) value; } int stack_empty(stack_t *stack) { return stack->_stacked == 0 ? 1 : 0; } Para alguns tipos você vai ter que usar uma conversão "especializada": void stack_push_float(stack_t *stack, float value) { float *persistent = ALLOC(sizeof(float)); *persistent = value; stack_push(stack, persistent); } float stack_pop_float(stack_t *stack) { float *persistent; float temp; persistent = (float *) stack_pop(stack); temp = *persistent; free(persistent); return temp; } stack.h: #ifndef STACK_H #define STACK_H #include "mem.h" typedef struct stack_s { ptr_t *_top; ptr_t *_ptr; int _stacked; int _alloc; } stack_t; /* ALLOCATION */ stack_t *stack_alloc(int quantity); stack_t *stack_create(); stack_t *stack_expand(stack_t *stack, int quantity); stack_t *stack_contract(stack_t *stack); void stack_free(stack_t **stack); /* ELEMENTS */ void *stack_top(stack_t *stack); void *stack_pop(stack_t *stack); void stack_push(stack_t *stack, void *value); int stack_empty(stack_t *stack); /* STACK EXPANSION FACTOR -> How much should go into quantity in a call to stack_expand when there's no allocated blocks left -> Maximum space waste is (STACK_EXPANSION_FACTOR * 8) (bytes) */ #define STACK_EXPANSION_FACTOR 1 #define print_stack(s) \ do { \ printf("Stack ");\ printf(#s);\ printf(" %p \n", s);\ printf("Number of elements: %d\nNumber of allocated blocks: %d\nTop element: %d\n\n", (s)->_stacked, (s)->_alloc, *((int *) stack_top(s))); \ } while(0); #endif mem.h: #ifndef MEM_H #define MEM_H #include <stdlib.h> #include <assert.h> static void *__graph__alloc_mem(int size) { void *block = malloc(size); assert(block); return block; } static void __graph__free_mem(void *ptr) { assert(ptr != NULL); free(ptr); } // coloque para 1 se estiver compilando para 64 bits (meu caso) #define IS_64_BITS 0 #ifdef IS_64_BITS typedef long long ptr_t; #else typedef int ptr_t; #endif #define DEBUG 1 #ifdef DEBUG #define ALLOC(x) __graph__alloc_mem(x); #define FREE(x) do { __graph__free_mem(x); x = 0; } while(0); #define free(x) __graph__free_mem(x); #else #define ALLOC(x) malloc(x); #define FREE(x) do { free(x); x = 0; } while(0); #define free(x) do { assert(x != NULL); free(x); } while(0); #endif #endif Ficou grande, mas acho que codeboxes prejudicam a legibilidade do "conjunto". Abraços!

Separe os três por "unidades"! Então: Lista duplamente encadeada: listadup.c listadup.h Lista: lista.c lista.h Pilha: pilha.c pilha.h Quando quiser usar uma, só incluir a "{estrutura}.h". Abraços!

Isto não está funcionando corretamente: int converte(char letra){ if (letra == 'a') letra = 97'; if (letra == 'b') letra = ´98'; if (letra == 'c') letra = '99'; if (letra == 'd') letra = '100'; return letra; } Tem alguns apostrofos faltando, uns "erradas", mas não é este o problema: não devia ter apostrofos. Apostrofos servem para transformar um caractere em ASCII: (as duas expressões abaixo são iguais) char c; c = 'A'; c = 65; O que você pode fazer para converter: 1. Percorrer cada caractere em um for 2. Escrever esse caractere na tela usando %d, ao invés de %c. Exemplo: printf("%d", (int) caractere); Abraços!

Ou você pode fazer um daemon e utilizar IPC, pra reduzir delays: http://msdn.microsoft.com/pt-br/library/aa365574(VS.85).aspx Mas... ; ) Abraços.

Qual sistema oepracional você está utilizando? Abraços.

Realmente, traduzindo pro português literalmente, seria "palavra", "palavra dupla", "palavra quadrática". (16 bits, 32 bits, 64 bits) Pelo pouco que li, parece que o compilador alinha a struct com o maior tamanho de uma variavel possivel. Exemplo: struct { char var; char var2; }; /* alinhamento = 1 byte */ struct { char var; char var2; short var3; } /* alinhamento = 2 bytes, mas nesse caso, não tem padding: | 1 byte - char | 1 byte - char 2 bytes - short ------------------ 4 bytes (2 char + 1 short) */ struct { char var; short var3; char var2; } /* alinhamento = 2 bytes e tem padding: 2 bytes - char (1 de padding) 2 bytes - short 2 bytes - char (1 de padding) ----------------------------------- 6 bytes (2 char + 1 short + 2 char) */ Talvez não seja exatamente assim, mas é mais ou menos o básico. Não li muito nessa parte. Sobre o código, realmente não tenho certeza. Me lembro que é alguma coisa parecida, e acho que já vi o pragma pack por aí. (provavelmente é do VC++) Da documentação do GCC (6.37): packed The packed attribute specifies that a variable or structure field should have the smallest possible alignment—one byte for a variable, and one bit for a field, unless you specify a larger value with the aligned attribute. No GCC tem síntaxe diferente, o exemplo que ele dá é o seguinte: /* Here is a structure in which the field x is packed, so that it immediately follows a: ou seja, não tem padding */ struct foo { char a; int x[2] __attribute__ ((packed)); }; Alguns programas fazem o padding manualmente, provavelmente para não dar problema. Já vi utilizarem isso no Blender. Abraços.

Vou marcar como resolvido e deixo uma dica: vejas as funções malloc, realloc, calloc e free, do stdlib.h. © Abraços!

Sim, se você alterar apenas uma porção do programa. O make guarda o que já está compilado e usa posteriormente, em uma futura compilação. Como já está compilado e ele só precisa linkar, é mais rápido. Para limpar esses arquivos salvos, use "make clean". (note que o Makefile deve suportar isso) Abraços.

Tente: #pragma pack(push) #pragma pack(1) struct t_medicamento { char codigo[10]; int categoria; char principioativo[50]; }; #pragma pack(pop) Não tenho certeza se este funciona com o compilador MinGW ("Dev-C++"). Abraços.

Ele não para no system("pause"), só pede para o usuário digitar uma tecla e continua a execução. É bom colocar o return 0, e usar getchar ao invés do system("pause") também. Abraços.

O que há de errado? Aparece um erro de compilação? O código está normal. Ele recebe vários valores em uma struct produto com nome de "item", e sai do programa. Abraços.

Marcando como resolvido. Abraços.