정의와 선언의 차이점은 무엇입니까?

정의와 선언의 차이점은 무엇입니까?

둘 다 무슨 뜻인지 모르겠다.

선언에서는 식별자가 도입되어 유형, 객체 또는 함수 중 어느 것이든 그 유형을 설명합니다.선언은 컴파일러가 해당 식별자에 대한 참조를 받아들이기 위해 필요한 것입니다.선언은 다음과 같습니다.

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

정의는 실제로 이 식별자를 인스턴스화/실장합니다.이러한 엔티티에 대한 참조를 링크하기 위해 링커에 필요한 것입니다.위의 선언에 대응하는 정의는 다음과 같습니다.

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

선언 대신 정의를 사용할 수 있습니다.

식별자는 원하는 빈도로 선언할 수 있습니다.따라서 C 및 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);

단, 1회만 정의해야 합니다.어딘가에서 선언 및 참조된 항목을 정의하는 것을 잊은 경우 링커는 참조를 링크할 대상을 알지 못하고 누락된 기호에 대해 불만을 제기합니다.여러 번 정의하면 링커는 어떤 정의를 링크해야 하는지 알 수 없으며 중복된 기호에 대해 불만을 제기합니다.

---

C++의 클래스 정의와 C++의 클래스 정의의 토론이 계속 되고 있기 때문에, 여기에 C++ 규격의 인용문을 붙입니다.
3.1/2로 C++03으로 됩니다.

선언은 [...]이(가) 클래스 이름 선언[...]이 아닌 한 정의입니다.

3.1/3은 몇 가지 예를 제시합니다.그 중:

[예: [...]구조 S { int a ; int b ; } ; //는 S, S::a 및 S::b [...]]구조 S; // S를 선언합니다.: 엔드 예시

표준에서는 C++로 간주됩니다.struct x;선언이 되다struct x {};정의(즉, C++에는 다른 형식의 클래스 선언이 없기 때문에, 「전송 선언」은 오칭입니다).

답변 중 하나에서 실제 장과 구절을 파낸 리트브(요하네스 샤우브)에게 감사한다.

선언: "어디엔가, foo가 존재한다."

정의: "...여기 있습니다!"

C++ 표준 섹션 3.1에서 다음을 수행합니다.

선언은 이름을 변환 유닛에 도입하거나 이전 선언에 의해 도입된 이름을 재배포합니다.선언은 이러한 이름의 해석과 속성을 지정합니다.

다음 단락은 (강조 내) 선언은 ...이 아니면 정의라고 기술한다.

... 함수의 본문을 지정하지 않고 함수를 선언합니다.

void sqrt(double);  // declares sqrt

... 클래스 정의 내에서 스태틱멤버를 선언합니다

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

... 클래스 이름을 선언합니다.

class Y;

에는 ...가 포함되어 있습니다.★★★★★★★★★★★★★★★★★★,extern이니셜라이저 또는 함수 본문이 없는 키워드:

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

... 또는typedef ★★★★★★★★★★★★★★★★★」using★★★★★★ 。

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

선언과 정의의 차이를 이해하는 것이 중요한 큰 이유로서1개의 정의 규칙입니다C++ 표준의 섹션 3.2.1부터:

변환 단위는 변수, 함수, 클래스 유형, 열거 유형 또는 템플릿의 정의를 두 개 이상 포함할 수 없습니다.

C++에는 흥미로운 엣지 케이스가 있습니다(그 중 일부는 C에도 있습니다.고려하다

T t;

될 수 .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".

C++에서는 템플릿을 사용할 때 다른 엣지 케이스가 있습니다.

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

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

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

마지막 선언은 정의가 아니었다.이것은 정적인 구성원의 명시적인 전문화 선언이다.X<bool>과 같이 」 ★★★★★★★★★★★★★★★★」X<bool>::member주 템플릿에서 구성원의 정의를 인스턴스화하지 않고 다른 곳에서 발견된 정의를 사용합니다.".

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

wiki.answers.com 에서 :

선언이라는 용어는 (C에서) 컴파일러에 대해 유형, 크기 및 함수 선언의 경우, 변수 파라미터의 유형과 크기 또는 프로그램 내의 사용자 정의 유형 또는 함수에 대해 알려주는 것을 의미합니다.선언 시 변수용으로 메모리에 예약된 공간은 없습니다.그러나 컴파일러는 이러한 유형의 변수가 생성되었을 때 예약해야 할 공간의 양을 알고 있습니다.

예를 들어, 모든 선언은 다음과 같습니다.

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

반면, 정의는 선언이 하는 모든 일에 더하여 공간이 메모리에 예약된다는 것을 의미합니다."DEFINITION = DECLIFORATION + SPACE RESERVAZION"은 다음과 같은 정의의 예입니다.

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

해답을 참조해 주세요.

C++11 업데이트

C++11과 관련된 답이 안 보이니까 여기 하나 있어요.

선언은 a/n을 선언하지 않는 한 정의입니다.

• enum - " " " 。enum X : int;
• 템플릿 매개 변수 - T intemplate<typename T> class MyArray;
• 매개 변수 선언 - x 및 y 위치int add(int x, int y);
• declaration - "에일리어스 선언:using IntVector = std::vector<int>;
• 선언 - " " " " :static_assert(sizeof(int) == 4, "Yikes!")
• 속성 선언(정보 정의)
• 선언 " " ";

위의 목록에 의해 C++03에서 상속된 추가 구:

• 함수 선언 - 추가int add(int x, int y);
• 또는 " " " " " 는 " " 입니다.extern int a; ★★★★★★★★★★★★★★★★★」extern "C" { ... };
• 클래스의 정적 데이터 멤버 - x inclass C { static int x; };
• 선언 - class/class 선언 -struct Point;
• - typedef "disclaration -typedef int Int;
• 을 사용합니다.using std::cout;
• using namespace NS;

template-declaration은 선언입니다.템플릿 선언은 선언이 함수, 클래스 또는 정적 데이터 멤버를 정의하는 경우에도 정의입니다.

선언과 정의를 구별하는 표준과 그 차이를 이해하는 데 도움이 되는 예는 다음과 같습니다.

// 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

C99 표준, 6.7(5)부터:

선언은 식별자 집합의 해석 및 속성을 지정합니다.식별자의 정의는 다음과 같은 식별자에 대한 선언입니다.

• 개체에 대해 해당 개체에 대해 스토리지를 예약합니다.
• 기능의 경우 기능 본체를 포함한다.
• 열거 상수 또는 typedef 이름의 경우 ID의 (유일한) 선언입니다.

C++ 표준 3.1 (2)부터:

선언은 함수의 본문을 지정하지 않고 함수를 선언하지 않는 한 정의이며, 외부 지정자 또는 링크 사양을 포함하며, 이니셜라이저도 함수 본문도 포함하지 않으며, 클래스 선언에서 정적 데이터 멤버를 선언하거나, 클래스 이름 선언이거나, typedef 선언이거나, a-declaration입니다.또는 사용법을 사용합니다.

그리고 몇 가지 예가 있습니다.

아니지만, 놀랐습니다), ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★」typedef int myint;의 이지만, C 의 입니다.

선언.

선언은 컴파일러에 프로그램 요소 또는 이름이 존재함을 알려줍니다.선언은 프로그램에 하나 이상의 이름을 도입합니다.선언은 프로그램에서 두 번 이상 발생할 수 있습니다.따라서 각 컴파일 유닛에 대해 클래스, 구조체, 열거형 및 기타 사용자 정의 유형을 선언할 수 있습니다.

정의.

정의는 이름이 설명하는 코드 또는 데이터를 지정합니다.이름을 사용하려면 먼저 이름을 선언해야 합니다.

그럼 명사를 이해하기 위해서 먼저 동사를 중심으로 이야기해 볼까요?

선언 - 공식적으로 발표하다

정의 - 명확하고 완전하게 (사물 또는 무엇인가를) 보여주거나 기술하는

그래서 신고할 때는 그냥 신고만 하면 되는 거죠.

// declaration
int sum(int, int);

이 행은 C 함수를 선언합니다.sum.int and and and및다 an 。int을 사용법

실제 작동 방식을 제공하는 것이 그 정의입니다.

// definition
int sum(int x, int y)
{
    return x + y;
}

선언과 정의의 차이를 이해하려면 어셈블리 코드를 확인해야 합니다.

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)

그리고 이것은 정의일 뿐입니다.

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)

보시다시피 아무것도 변하지 않았어요.

선언은 컴파일러에 의해서만 사용되는 정보를 제공하기 때문에 정의와는 다릅니다.예를 들어 uint8_t는 asm 함수 movb를 사용하도록 컴파일러에 지시합니다.

다음을 참조하십시오.

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

선언은 실행할 대상이 아니기 때문에 동등한 명령이 없습니다.

또한 선언은 변수의 범위를 컴파일러에 알려줍니다.

선언은 컴파일러가 변수의 올바른 사용 및 일부 메모리가 특정 변수에 속하는 기간을 설정하기 위해 사용하는 정보라고 할 수 있습니다.

변수 선언은 변수 이름, 변수 보유 유형 및 초기 값(필요한 경우)을 컴파일러에 알리기 위한 것입니다. 즉, 선언은 변수의 속성에 대한 세부 정보를 제공합니다.반면 변수의 정의는 변수의 저장 위치를 나타냅니다. 즉, 변수의 메모리는 변수의 정의 중에 할당됩니다.

여기에서 유사한 답변을 찾을 수 있습니다.C의 테크니컬 인터뷰 질문

선언은 프로그램에 이름을 제공하고 정의는 프로그램 내의 엔티티(예: 유형, 인스턴스 및 함수)에 대한 고유한 설명을 제공합니다.선언은 지정된 범위에서 반복할 수 있으며, 지정된 범위에 이름이 추가됩니다.

선언은 다음의 경우를 제외하고 정의입니다.

• 선언은 본문을 지정하지 않고 함수를 선언합니다.
• 선언에 외부 지정자가 포함되며 이니셜라이저나 함수 본문이 없습니다.
• 선언은 클래스 정의가 없는 정적 클래스 데이터 멤버의 선언입니다.
• 선언은 클래스 이름 정의입니다.

정의는 다음의 경우를 제외하고 선언입니다.

• 정의는 정적 클래스 데이터 멤버를 정의합니다.
• 정의는 비 인라인 멤버 함수를 정의합니다.

정의:

extern int a;      // Declaration 
int a;             // Definition
a = 10             // Initialization
int b = 10;        // Definition & Initialization

정의는 변수를 유형과 관련지어 메모리를 할당하는 반면 선언은 유형을 지정하기만 할 뿐 메모리를 할당하지는 않습니다.선언은 정의 전에 변수를 참조하려는 경우에 더 유용합니다.

*정의와 초기화를 혼동하지 마십시오.둘 다 다르므로 초기화는 변수에 가치를 부여합니다.위의 예를 참조해 주세요.

다음은 정의의 몇 가지 예입니다.

int a;
float b;
double c;

이제 함수 선언:

int fun(int a,int b); 

함수의 끝에 세미콜론이 있으므로 선언에 불과하다고 표시됩니다.컴파일러는 프로그램 어딘가에서 그 함수가 그 프로토타입으로 정의된다는 것을 알고 있습니다.컴파일러가 다음과 같은 함수를 호출하면

int b=fun(x,y,z);

컴파일러는 이러한 함수가 없음을 나타내는 오류를 발생시킵니다.그 기능을 위한 시제품이 없기 때문입니다.

두 프로그램의 차이점에 유의하십시오.

프로그램 1

#include <stdio.h>
void print(int a)
{
     printf("%d",a);
}
main()
{
    print(5);
}

이 때, 인쇄 기능도 선언해 정의한다.정의 후에 함수 호출이 오므로.이제 다음 프로그램을 보십시오.

프로그램 2

 #include <stdio.h>
 void print(int a); // In this case this is essential
 main()
 {
    print(5);
 }
 void print(int a)
 {
     printf("%d",a);
 }

함수 호출이 정의보다 우선하기 때문에 컴파일러는 이러한 함수가 있는지 여부를 알아야 합니다.따라서 컴파일러에 알릴 함수를 선언합니다.

정의:

함수를 정의하는 이 부분을 정의라고 합니다.기능 안에서 무엇을 해야 하는지 나와 있습니다.

void print(int a)
{
    printf("%d",a);
}

경험칙:

• 선언은 컴파일러가 메모리에 있는 변수의 데이터를 해석하는 방법을 알려줍니다.이것은 모든 액세스에 필요합니다.

• 정의는 변수를 존재시키기 위해 메모리를 예약합니다.이 작업은 첫 번째 액세스 전에 정확히 한 번 수행해야 합니다.

선언은 컴파일러에 기호 이름을 나타냅니다.정의는 기호를 위한 공간을 할당하는 선언입니다.

int f(int x); // function declaration (I know f exists)

int f(int x) { return 2*x; } // declaration and definition

definition은 실제 함수를 나타내고 declaration은 예를 들어 단순한 선언 함수를 의미합니다.

void  myfunction(); //this is simple declaration

그리고.

void myfunction()
{
 some statement;    
}

이것은 기능 myfunction의 정의이다.

GNU C 라이브러리 매뉴얼(http://www.gnu.org/software/libc/manual/html_node/Header-Files.html)에 따라 주세요.

C에서 선언은 함수나 변수가 존재한다는 정보를 제공하고 그 유형을 제공할 뿐이다.함수 선언의 경우 인수 유형에 대한 정보도 제공될 수 있습니다.선언의 목적은 컴파일러가 선언된 변수와 함수에 대한 참조를 올바르게 처리할 수 있도록 하는 것입니다.반면, 정의는 실제로 변수에 스토리지를 할당하거나 함수가 수행하는 작업을 나타냅니다.

선언은 스토리지가 할당되지 않고 정의가 선언된 식별자에서 스토리지를 실제로 할당하는 식별자임을 가능한 한 일반적인 용어로 설명할 수 없습니까?

한 가지 흥미로운 생각은 클래스 또는 함수가 유형 정보와 연결될 때까지 템플릿을 통해 스토리지를 할당할 수 없다는 것입니다.템플릿 식별자는 선언입니까, 정의입니까?스토리지는 할당되어 있지 않고 템플릿 클래스 또는 함수를 '프로토타이핑'하고 있을 뿐이므로 선언이어야 합니다.

선언이란 변수(변수 선언의 경우)에 이름과 유형을 지정하는 것을 의미합니다. 예:

int i;

또는 (함수 선언의 경우) 본문이 없는 함수에 이름, 반환 유형 및 매개 변수 유형을 지정합니다. 예:

int max(int, int);

정의란 변수(변수 정의의 경우)에 값을 할당하는 것을 의미합니다. 예:

i = 20;

또는 본문(기능)을 함수에 제공/추가하는 것을 함수 정의라고 합니다.예를 들어 다음과 같습니다.

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

다음과 같이 많은 시간 선언과 정의를 함께 수행할 수 있습니다.

int i=20;

또, 다음과 같이 합니다.

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

변수를 합니다.i ★★★★★★★★★★★★★★★★★」function max().

정말 유치하게 들리겠지만 내 머릿속에 그 말을 바로 담을 수 있었던 가장 좋은 방법이야.

선언:토마스 제퍼슨이 연설하는 사진..."이 FOO가 이 소스코드에 존재함을 선언합니다!!!"

정의: 사전을 상상해 보십시오. Foo와 그것이 실제로 무엇을 의미하는지 찾아봅니다.

외부 스토리지 클래스를 사용할 때 Declaration and Definition의 개념은 함정을 형성합니다. 정의가 다른 위치에 있고 로컬 코드 파일(페이지)에서 변수를 선언하고 있기 때문입니다.C와 C++의 한 가지 차이점은 C에서는 선언이 함수 또는 코드 페이지의 시작 부분에서 정상적으로 수행된다는 것입니다.C++에서는 그렇지 않습니다.원하는 장소에서 신고할 수 있습니다.

여기서 가장 좋아하는 예는 "int Num = 5"입니다. 변수는 1. int 2. Num으로 선언되고 3. 값이 5로 인스턴스화됩니다.우리가

• 개체 유형을 정의합니다. 개체 유형은 기본 제공 또는 클래스 또는 구조일 수 있습니다.
• 개체 이름을 선언하여 변수, 함수 등을 포함하는 이름을 가진 항목이 선언되도록 합니다.

클래스 또는 구조를 사용하면 나중에 개체를 사용할 때 개체를 정의하는 방법을 변경할 수 있습니다.예를들면

• 특별히 정의되지 않은 이종 변수 또는 배열을 선언할 수 있습니다.
• C++의 오프셋을 사용하여 선언된 이름이 없는 개체를 정의할 수 있습니다.

우리가 프로그래밍을 배울 때, 이 두 용어는 종종 동시에 하기 때문에 종종 혼동된다.

실행 파일 생성 단계:

(1) 프리클리어 -> (2) 번역자 / 번역자 -> (3) 링커

스테이지 2(번역기/컴파일러)에서는 코드 내의 선언문이 컴파일러에 대해 향후 사용할 예정이며 나중에 정의를 찾을 수 있음을 알려줍니다.즉, 다음과 같습니다.

translator는 "what is?"가 선언을 의미하는지 확인합니다.

그리고 (3) 스테이지(링커)는 사물을 묶기 위한 정의가 필요하다.

링커: where is what?가 정의를 의미하는지 확인합니다.

K&R(제2판)에는 명확한 정의가 몇 가지 있습니다.한 곳에 모아 하나로 읽는 데 도움이 됩니다.

"정의"는 변수가 생성되거나 저장소가 할당된 위치를 의미하며, "선언"은 변수의 특성이 명시되어 있지만 저장소가 할당되지 않은 위치를 의미합니다.[p.33]

...

외부 변수의 선언과 그 정의를 구별하는 것이 중요합니다.선언은 변수 속성(주로 변수 유형)을 알립니다. 정의에 따라 저장공간도 확보됩니다.행이

int sp;
double val[MAXVAL]

기능 외부에 나타나며 외부 변수를 정의합니다.sp그리고.val스토리지를 확보하여 해당 소스 파일의 나머지 부분에 대한 선언 역할을 합니다.

반면, 그 대사들은

extern int sp;
extern double val[];

소스 파일의 나머지 부분에 대해 라고 선언하다sp는 입니다.int그리고 그것val는 입니다.double어레이(하드웨어 크기는 다른 곳에서 결정되지만 변수를 생성하거나 해당 변수를 위해 스토리지를 예약하지는 않습니다).

소스 프로그램을 구성하는 모든 파일 중 외부 변수의 정의는 하나만 있어야 합니다. ...어레이 사이즈는 정의에서 지정해야 합니다만,extern][80-81]

...

선언은 각 식별자에 대한 해석을 지정합니다. 식별자와 관련된 저장소를 예약하지 않아도 됩니다.스토리지를 예약하는 선언을 정의라고 합니다.[페이지 210]

선언은 값이나 개체를 할당하지 않고 원시 또는 개체 참조 변수 또는 메서드가 생성된 경우입니다.int a; 최종 int a;

정의란 값 또는 객체를 각각 a=10에 할당하는 것을 의미한다.

초기화란 각 변수 또는 오브젝트에 메모리를 할당하는 것을 의미합니다.

언급URL : https://stackoverflow.com/questions/1410563/what-is-the-difference-between-a-definition-and-a-declaration