use c++ function in c




Qual é a diferença entre uma definição e uma declaração? (15)

O significado de ambos me ilude.


Atualização do C ++ 11

Desde que eu não vejo uma resposta pertinente ao C + + 11 aqui está um.

Uma declaração é uma definição, a menos que ela declare a / n:

  • enum opaco - enum X : int;
  • parâmetro de modelo - T no template<typename T> class MyArray;
  • declaração de parâmetro - x e y em int add(int x, int y);
  • declaração de alias - using IntVector = std::vector<int>;
  • declaração estática de declaração - static_assert(sizeof(int) == 4, "Yikes!")
  • declaração de atributo (definida pela implementação)
  • declaração vazia ;

Cláusulas adicionais herdadas de C ++ 03 pela lista acima:

  • declaração de função - adicionar em int add(int x, int y);
  • especificador externo contendo declaração ou um especificador de ligação - extern int a; ou extern "C" { ... };
  • membro de dados estáticos em uma classe - x na class C { static int x; }; class C { static int x; };
  • declaração de classe / estrutura - struct Point;
  • declaração typedef - typedef int Int;
  • usando declaração - using std::cout;
  • usando diretiva - using namespace NS;

Uma declaração de modelo é uma declaração. Uma declaração de modelo também é uma definição se sua declaração definir uma função, uma classe ou um membro de dados estático.

Exemplos do padrão que diferencia entre declaração e definição que achei útil para entender as nuances entre eles:

// except one all these are definitions
int a;                                  // defines a
extern const int c = 1;                 // defines c
int f(int x) { return x + a; }          // defines f and defines x
struct S { int a; int b; };             // defines S, S::a, and S::b
struct X {                              // defines X
    int x;                              // defines non-static data member x
    static int y;                       // DECLARES static data member y
    X(): x(0) { }                       // defines a constructor of X
};
int X::y = 1;                           // defines X::y
enum { up , down };                     // defines up and down
namespace N { int d; }                  // defines N and N::d
namespace N1 = N;                       // defines N1
X anX;                                  // defines anX


// all these are declarations
extern int a;                           // declares a
extern const int c;                     // declares c
int f(int);                             // declares f
struct S;                               // declares S
typedef int Int;                        // declares Int
extern X anotherX;                      // declares anotherX
using N::d;                             // declares N::d


// specific to C++11 - these are not from the standard
enum X : int;                           // declares X with int as the underlying type
using IntVector = std::vector<int>;     // declares IntVector as an alias to std::vector<int>
static_assert(X::y == 1, "Oops!");      // declares a static_assert which can render the program ill-formed or have no effect like an empty declaration, depending on the result of expr
template <class T> class C;             // declares template class C
;                                       // declares nothing

Da seção padrão C ++ 3.1:

Uma declaração introduz nomes em uma unidade de tradução ou redeclama nomes introduzidos por declarações anteriores. Uma declaração especifica a interpretação e os atributos desses nomes.

O próximo parágrafo afirma (ênfase minha) que uma declaração é uma definição a menos que ...

... declara uma função sem especificar o corpo da função

void sqrt(double);  // declares sqrt

... declara um membro estático dentro de uma definição de classe

struct X
{
    int a;         // defines a
    static int b;  // declares b
};

... declara um nome de classe

class Y;

... contém a palavra-chave extern sem um inicializador ou corpo de função

extern const int i = 0;  // defines i
extern int j;  // declares j
extern "C"
{
    void foo();  // declares foo
}

... ou é um typedef ou using instrução.

typedef long LONG_32;  // declares LONG_32
using namespace std;   // declares std

Agora, pela grande razão, é importante entender a diferença entre uma declaração e uma definição: a regra de uma definição . Da seção 3.2.1 do padrão C ++:

Nenhuma unidade de tradução deve conter mais de uma definição de qualquer variável, função, tipo de classe, tipo de enumeração ou modelo.


De wiki.answers.com:

O termo declaração significa (em C) que você está dizendo ao compilador sobre o tipo, tamanho e no caso da declaração da função, tipo e tamanho de seus parâmetros de qualquer variável, ou tipo ou função definida pelo usuário em seu programa. Nenhum espaço é reservado na memória para qualquer variável em caso de declaração. No entanto, o compilador sabe quanto espaço reservar, caso uma variável desse tipo seja criada.

por exemplo, seguem todas as declarações:

extern int a; 
struct _tagExample { int a; int b; }; 
int myFunc (int a, int b);

Definição, por outro lado, significa que, em acréscimos a todas as coisas que a declaração faz, o espaço também é reservado na memória. Você pode dizer "DEFINIÇÃO = DECLARAÇÃO + RESERVA DE ESPAÇO" a seguir são exemplos de definição:

int a; 
int b = 0; 
int myFunc (int a, int b) { return a + b; } 
struct _tagExample example; 

veja Answers .


Declaração significa dar nome e tipo a uma variável (no caso de declaração variável), por exemplo:

 int i;  

ou nome, tipo de retorno e tipo (s) de parâmetro para uma função sem corpo (no caso de declaração de função)

por exemplo:

int max(int, int);

enquanto definição significa atribuir valor a uma variável (no caso de definição variável). por exemplo:

i = 20;

ou fornecer / adicionar corpo (funcionalidade) a uma função é chamada de definição de função.

por exemplo:

 int max(int a, int b)
 {
    if(a>b)   return a;
    return b;  
 }

muitas vezes a declaração e a definição podem ser feitas juntas como:

int i=20;   

e

int max(int a, int b)
{
    if(a>b)   return a;
    return b;    
} 

Nos casos acima definimos e declaramos a variável i e a função max ()


Do padrão C99, 6.7 (5):

Uma declaração especifica a interpretação e os atributos de um conjunto de identificadores. Uma definição de um identificador é uma declaração para esse identificador que:

  • para um objeto, faz com que o armazenamento seja reservado para esse objeto;
  • para uma função, inclui o corpo da função;
  • para uma constante de enumeração ou nome typedef, é a declaração (somente) do identificador.

Do padrão C ++, 3.1 (2):

Uma declaração é uma definição, a menos que declare uma função sem especificar o corpo da função, contenha o especificador externo ou uma especificação de ligação e nem um inicializador nem um corpo de função, declare um membro de dados estáticos em uma declaração de classe, seja um declaração de nome de classe, ou é uma declaração typedef, uma declaração de uso ou uma diretiva using.

Então há alguns exemplos.

Tão interessante (ou não, mas estou um pouco surpreso com isso), typedef int myint; é uma definição em C99, mas apenas uma declaração em C ++.


Encontre respostas semelhantes aqui: Perguntas técnicas sobre entrevistas em C

Uma declaração fornece um nome para o programa; Uma definição fornece uma descrição única de uma entidade (por exemplo, tipo, instância e função) dentro do programa. Declarações podem ser repetidas em um determinado escopo, ele introduz um nome em um determinado escopo.

Uma declaração é uma definição, a menos

  • Declaração declara uma função sem especificar seu corpo,
  • Declaração contém um especificador externo e nenhum inicializador ou corpo de função,
  • Declaração é a declaração de um membro de dados de classe estática sem uma definição de classe,
  • Declaração é uma definição de nome de classe,

Uma definição é uma declaração, a menos que:

  • Definição define um membro de dados de classe estática,
  • Definição define uma função de membro não embutida.

Existem casos de borda interessantes em C ++ (alguns deles em C também). Considerar

T t;

Isso pode ser uma definição ou uma declaração, dependendo do tipo de T :

typedef void T();
T t; // declaration of function "t"

struct X { 
  T t; // declaration of function "t".
};

typedef int T;
T t; // definition of object "t".

Em C ++, ao usar modelos, há outro caso de borda.

template <typename T>
struct X { 
  static int member; // declaration
};

template<typename T>
int X<T>::member; // definition

template<>
int X<bool>::member; // declaration!

A última declaração não foi uma definição. É a declaração de uma especialização explícita do membro estático de X<bool> . Diz ao compilador: "Se for instanciar o X<bool>::member , então não instancie a definição do membro do template primário, mas use a definição encontrada em outro lugar". Para torná-lo uma definição, você precisa fornecer um inicializador

template<>
int X<bool>::member = 1; // definition, belongs into a .cpp file.

Isso vai soar realmente extravagante, mas é a melhor maneira que consegui manter os termos diretos na minha cabeça:

Declaração: Imagine Thomas Jefferson fazendo um discurso ... "EU DISSO DECLARO QUE ESTE FOO EXISTE NESTE CÓDIGO FONTE !!!"

Definição: imagine um dicionário, você está procurando por Foo e o que isso realmente significa.


O conceito de Declaração e Definição formará uma armadilha quando você estiver usando a classe de armazenamento externo porque sua definição estará em algum outro local e você estará declarando a variável em seu arquivo de código local (página). Uma diferença entre C e C ++ é que, em C, as declarações são feitas normalmente no início de uma função ou página de código. Em C ++ não é assim. Você pode declarar em um lugar de sua escolha.


Para entender a diferença entre declaração e definição, precisamos ver o código assembly:

uint8_t   ui8 = 5;  |   movb    $0x5,-0x45(%rbp)
int         i = 5;  |   movl    $0x5,-0x3c(%rbp)
uint32_t ui32 = 5;  |   movl    $0x5,-0x38(%rbp)
uint64_t ui64 = 5;  |   movq    $0x5,-0x10(%rbp)
double   doub = 5;  |   movsd   0x328(%rip),%xmm0        # 0x400a20
                        movsd   %xmm0,-0x8(%rbp)

e esta é apenas a definição:

ui8 = 5;   |   movb    $0x5,-0x45(%rbp)
i = 5;     |   movl    $0x5,-0x3c(%rbp)
ui32 = 5;  |   movl    $0x5,-0x38(%rbp)
ui64 = 5;  |   movq    $0x5,-0x10(%rbp)
doub = 5;  |   movsd   0x328(%rip),%xmm0        # 0x400a20
               movsd   %xmm0,-0x8(%rbp)

Como você pode ver, nada muda.

A declaração é diferente da definição porque fornece informações usadas apenas pelo compilador. Por exemplo, uint8_t diz ao compilador para usar a função asm movb.

Veja isso:

uint def;                  |  no instructions
printf("some stuff...");   |  [...] callq   0x400450 <[email protected]>
def=5;                     |  movb    $0x5,-0x45(%rbp)

A declaração não tem uma instrução equivalente porque não é algo a ser executado.

Além disso, a declaração informa ao compilador o escopo da variável.

Podemos dizer que a declaração é uma informação usada pelo compilador para estabelecer o uso correto da variável e por quanto tempo alguma memória pertence a determinada variável.


Regra de ouro:

  • Uma declaração informa ao compilador como interpretar os dados da variável na memória. Isso é necessário para todos os acessos.

  • Uma definição reserva a memória para tornar a variável existente. Isso tem que acontecer exatamente uma vez antes do primeiro acesso.


Uma declaração introduz um identificador e descreve seu tipo, seja um tipo, objeto ou função. Uma declaração é o que o compilador precisa aceitar referências a esse identificador. Estas são declarações:

extern int bar;
extern int g(int, int);
double f(int, double); // extern can be omitted for function declarations
class foo; // no extern allowed for type declarations

Uma definição realmente instancia / implementa esse identificador. É o que o vinculador precisa para vincular referências a essas entidades. Estas são definições correspondentes às declarações acima:

int bar;
int g(int lhs, int rhs) {return lhs*rhs;}
double f(int i, double d) {return i+d;}
class foo {};

Uma definição pode ser usada no lugar de uma declaração.

Um identificador pode ser declarado quantas vezes você quiser. Assim, o seguinte é legal em C e C ++:

double f(int, double);
double f(int, double);
extern double f(int, double); // the same as the two above
extern double f(int, double);

No entanto, deve ser definido exatamente uma vez. Se você se esquecer de definir algo que foi declarado e referenciado em algum lugar, o vinculador não saberá o que vincular referências e reclamará sobre os símbolos ausentes. Se você definir algo mais de uma vez, o vinculador não saberá qual das definições para vincular referências e reclamações sobre símbolos duplicados.

Desde o debate que é uma declaração de classe versus uma definição de classe em C ++ continua chegando (em respostas e comentários para outras questões), eu vou colar uma citação do padrão C ++ aqui.
Em 3.1 / 2, o C ++ 03 diz:

Uma declaração é uma definição, a menos que [...] seja uma declaração de nome de classe [...].

3.1 / 3, em seguida, dá alguns exemplos. Dentre elas:

[Example: [...]
struct S { int a; int b; }; // defines S, S::a, and S::b [...]
struct S; // declares S
—end example

Resumindo: O padrão C ++ considera a struct x; ser uma declaração e struct x {}; uma definição . (Em outras palavras, "declaração direta" um nome incorreto , uma vez que não há outras formas de declarações de classe em C ++.)

Graças a litb (Johannes Schaub), que cavou o capítulo real e verso em uma de suas respostas.


Você não poderia declarar nos termos mais gerais possíveis, que uma declaração é um identificador no qual nenhum armazenamento é alocado e uma definição realmente aloca armazenamento de um identificador declarado?

Um pensamento interessante - um modelo não pode alocar armazenamento até que a classe ou função esteja vinculada às informações de tipo. Então, o identificador de modelo é uma declaração ou definição? Deve ser uma declaração, já que nenhum armazenamento é alocado, e você está simplesmente "prototipando" a classe ou função do modelo.


definição significa função real escrita e declaração significa simples função declare por exemplo

void  myfunction(); //this is simple declaration

e

void myfunction()
{
 some statement;    
}

esta é a definição da função myfunction


Declaração

Declarações dizem ao compilador que existe um elemento ou nome do programa. Uma declaração introduz um ou mais nomes em um programa. Declarações podem ocorrer mais de uma vez em um programa. Portanto, classes, estruturas, tipos enumerados e outros tipos definidos pelo usuário podem ser declarados para cada unidade de compilação.

Definição

As definições especificam qual código ou dado o nome descreve. Um nome deve ser declarado antes de poder ser usado.





c++-faq