ti-enxame.com

São typedef e #define o mesmo em c?

Gostaria de saber se typedef e #define são os mesmos em c ?

106
hdn

Não.

#define é um token de pré-processador: o próprio compilador nunca o verá.
typedef é um token de compilador: o pré-processador não se importa com isso.

Você pode usar um ou outro para obter o mesmo efeito, mas é melhor usar o apropriado para suas necessidades

#define MY_TYPE int
typedef int My_Type;

Quando as coisas ficam "peludas", usar a ferramenta adequada faz tudo certo

#define FX_TYPE void (*)(int)
typedef void (*stdfx)(int);

void fx_typ(stdfx fx); /* ok */
void fx_def(FX_TYPE fx); /* error */
106
pmg

typedef obedece as regras de escopo assim como as variáveis, enquanto define permanece válido até o final do arquivo (ou até uma correspondência undef).

Além disso, algumas coisas podem ser feitas com typedef que não podem ser feitas com define.

Exemplos:

typedef int* int_p1;
int_p1 a, b, c;  // a, b, and c are all int pointers.

#define int_p2 int*
int_p2 a, b, c;  // only the first is a pointer!

.

typedef int a10[10];
a10 a, b, c; // create three 10-int arrays

.

typedef int (*func_p) (int);
func_p fp // func_p is a pointer to a function that
          // takes an int and returns an int
207
Andreas Grech

Não, eles não são iguais. Por exemplo:

#define INTPTR int*
...
INTPTR a, b;

Após o pré-processamento, essa linha se expande para

int* a, b;

Espero que você veja o problema; somente a terá o tipo int *; b será declarado como int simples (porque o * está associado ao declarator, não ao especificador de tipo). 

Compare isso com

typedef int *INTPTR;
...
INTPTR a, b;

Nesse caso, a e b terão o tipo int *

Existem classes inteiras de typedefs que não podem ser emuladas com uma macro de pré-processador, como ponteiros para funções ou matrizes:

typedef int (*CALLBACK)(void);
typedef int *(*(*OBNOXIOUSFUNC)(void))[20]; 
...
CALLBACK aCallbackFunc;        // aCallbackFunc is a pointer to a function 
                               // returning int
OBNOXIOUSFUNC anObnoxiousFunc; // anObnoxiousFunc is a pointer to a function
                               // returning a pointer to a 20-element array
                               // of pointers to int

Tente fazer isso com uma macro de pré-processamento. 

21
John Bode

#define define macros.
typedef define tipos.

Agora dizendo isso, aqui estão algumas diferenças:

Com #define você pode definir constantes que podem ser usadas em tempo de compilação. As constantes podem ser usadas com #ifdef para verificar como o código é compilado e especializar determinado código de acordo com os parâmetros de compilação.
Você também pode usar #define para declarar encontrar e substituir miniaturas Funções de macro.

typedef pode ser usado para dar aliases para tipos (o que você provavelmente poderia fazer com #define também), mas é mais seguro por causa da natureza de localizar e substituir de #define constantes.
Além disso, você pode usar forward declaration com typedef que permite declarar um tipo que será usado, mas ainda não está vinculado a o arquivo que você está escrevendo.

12
Yochai Timmer

Macros de pré-processamento ("#define 's") são uma ferramenta de substituição lexical a la "search and replace". Eles são totalmente agnósticos da linguagem de programação e não entendem o que você está tentando fazer. Você pode pensar neles como uma mecânica de copiar/colar glorificada - ocasionalmente isso é útil, mas você deve usá-lo com cuidado.

Typedefs são um recurso da linguagem C que permite criar aliases para tipos. Isso é extremamente útil para tornar tipos compostos complicados (como structs e ponteiros de função) legíveis e manuais (em C++ existem até situações em que você deve typedef um tipo).

Para (3): você deve sempre preferir recursos de idioma sobre macros de pré-processamento, quando isso for possível! Portanto, sempre use typedefs para tipos e valores constantes para constantes. Dessa forma, o compilador pode realmente interagir com você de maneira significativa. Lembre-se que o compilador é seu amigo, então você deve dizer o máximo possível. As macros de pré-processamento fazem exatamente o oposto por ocultação sua semântica do compilador.

5
Kerrek SB

Eles são muito diferentes, embora sejam usados ​​frequentemente para implementar tipos de dados personalizados (que é o que eu estou supondo que esta questão é toda sobre).

Como mencionado por pmg, #define é manipulado pelo pré-processador (como uma operação de recortar e colar) antes do compilador ver o código, e typedef é interpretado pelo compilador.

Uma das principais diferenças (pelo menos quando se trata de definir tipos de dados) é que typedef permite uma verificação de tipo mais específica. Por exemplo,

#define defType int
typedef int tdType

defType x;
tdType y;

Aqui, o compilador vê a variável x como um int, mas a variável y como um tipo de dados chamado 'tdType' que é do mesmo tamanho que um int. Se você escreveu uma função que tomou um parâmetro do tipo defType, o chamador poderia passar um int normal e o compilador não saberia a diferença. Se, em vez disso, a função utilizasse um parâmetro do tipo tdType, o compilador garantiria que uma variável do tipo apropriado fosse usada durante as chamadas de função.

Além disso, alguns depuradores têm a capacidade de manipular typedefs, o que pode ser muito mais útil do que ter todos os tipos personalizados listados como seus tipos primitivos subjacentes (como seria se #define fosse usado em vez disso).

3
bta

Não. 
typedef é uma palavra-chave C que cria um alias para um tipo.
#define é uma instrução pré-processador, que cria um evento de substituição de texto antes da compilação. Quando o compilador chega ao código, o Word "#defined" original não está mais lá. #define é usado principalmente para macros e constantes globais.

2
Traveling Tech Guy

AFAIK, não. 

'typedef' ajuda você a configurar um "alias" para um tipo de dados existente. Por exemplo typedef char chr; 

#define é uma diretiva preprocessor usada para definir macros ou subposições gerais de padrão. Por exemplo #define MAX 100, substitui todas as ocorrências de MAX por 100

1
user59634

Como todos disseram acima, eles não são os mesmos. A maioria das respostas indica que typedef é mais vantajoso que #define. Mas deixe-me colocar um ponto positivo de #define:
quando seu código é extremamente grande, espalhado em vários arquivos, é melhor usar #define; ajuda na legibilidade - você pode simplesmente pré-processar todo o código para ver a definição de tipo real de uma variável no local de sua própria declaração.

0
abcoep