it-swarm-ko.com

C ++로 열거 형 선언하기

다음과 같은 일을하려고합니다.

enum E;

void Foo(E e);

enum E {A, B, C};

컴파일러가 거부합니다. Google을 간략히 살펴 봤는데 컨센서스는 "당신이 할 수 없습니다"인 것 같지만 그 이유를 이해할 수 없습니다. 누구든지 설명 할 수 있습니까?

설명 2 : enum을 사용하는 클래스에 개인 메서드가 있으므로이 작업을 수행하고 있으며 enum의 값을 노출하지 않기를 원합니다. 예를 들어, 누군가 E가 다음과 같이 정의되어 있음을 알기를 원하지 않습니다.

enum E {
    FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X
}

프로젝트 X는 사용자가 알고 싶어하는 것이 아닙니다.

그래서 개인 메소드를 헤더 파일에 넣고 내부적으로 enpp를 cpp에 선언하고 빌드 된 라이브러리 파일과 헤더를 사람들에게 배포 할 수 있도록 열거 형을 전달하고 싶습니다.

컴파일러는 GCC입니다.

253
szevvy

열거 형을 전달할 수없는 이유는 값을 알지 못하면 컴파일러가 열거 형 변수에 필요한 저장 공간을 알 수 없기 때문입니다. C++ 컴파일러는 지정된 모든 값을 포함하는 데 필요한 크기를 기반으로 실제 저장 공간을 지정할 수 있습니다. 보이는 모든 것이 순방향 선언이라면, 번역 단위는 어떤 스토리지 크기가 선택 될지 알 수 없습니다. char, int 또는 다른 것이 될 수 있습니다.


ISO C++ 표준의 7.2.5 섹션에서 :

열거 형의 기본 형식 은 열거 형에 정의 된 모든 열거 자 값을 나타낼 수있는 정수 형식입니다. 열거 자의 값이 int 또는 unsigned int에 맞지 않는 한 기본 유형이 int보다 크지 않아야한다는 점을 제외하고 열거의 기본 유형으로 사용되는 정수 유형이 구현 정의되어 있습니다. 열거 자 목록 이 비어 있으면 기본 형식은 열거에 값이 0 인 단일 열거자가있는 것처럼 나타납니다. sizeof() 열거 형, 열거 형의 객체 또는 열거 자에 적용되는 것은 기본 유형에 적용된 sizeof()의 값입니다.

함수에 대한 caller 는 호출 스택을 올바르게 설정하기 위해 매개 변수의 크기를 알아야하므로 열거 목록의 열거 수를 미리 알아야합니다. 함수 프로토 타입.

업데이트 : C++ 0X에서 열거 형을 선언하는 구문이 제안되어 승인되었습니다. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf 에서 제안을 볼 수 있습니다.

206
KJAWolf

C++ 0x에서도 열거 형을 선언 할 수 있습니다. 이전에는 열거 형 유형을 전달할 수없는 이유는 열거의 크기가 내용에 따라 달라지기 때문입니다. 열거의 크기가 응용 프로그램에 의해 지정되는 한 전달 선언 될 수 있습니다.

enum Enum1;                   //Illegal in C++ and C++0x; no size is explicitly specified.
enum Enum2 : unsigned int;    //Legal in C++0x.
enum class Enum3;             //Legal in C++0x, because enum class declarations have a default type of "int".
enum class Enum4: unsigned int; //Legal C++0x.
enum Enum2 : unsigned short;  //Illegal in C++0x, because Enum2 was previously declared with a different type.
188
user119017

최근의 발전에 따라 여기에 최신 답변을 추가하고 있습니다.

스토리지 유형을 동시에 선언하는 한 C++ 11에서 열거 형을 전달할 수 있습니다. 구문은 다음과 같습니다.

enum E : short;
void foo(E e);

....

enum E : short
{
    VALUE_1,
    VALUE_2,
    ....
}

실제로 함수가 열거 값을 참조하지 않으면 해당 시점에서 완전한 선언이 필요하지 않습니다.

이것은 G ++ 4.6 이상에서 지원됩니다 (최신 버전에서는 -std=c++0x 또는 -std=c++11). Visual C++ 2013은이를 지원합니다. 이전 버전에서는 아직 알지 못했던 일종의 비표준 지원이 있습니다. 간단한 전달 선언은 합법적이지만 YMMV라는 제안이 있습니다.

73
Tom

C++에서 선언하는 것은 컴파일 시간을 크게 단축시킵니다 이므로 매우 유용합니다. C++에서 struct, class, function 등을 포함하여 여러 가지를 선언 할 수 있습니다.

그러나 C++에서 enum을 선언 할 수 있습니까?

아뇨.

그러나 왜 허용하지 않습니까? 허용 된 경우 헤더 파일에서 enum 유형을 정의하고 소스 파일에서 enum 값을 정의 할 수 있습니다. 제대로 허용되어야합니까?

잘못된.

C++에는 C # (int)에있는 것처럼 enum에 대한 기본 유형이 없습니다. C++에서 enum 유형은 enum에 대한 값 범위에 맞는 모든 유형으로 컴파일러에 의해 결정됩니다.

그게 무슨 뜻이야?

이는 enum의 모든 값이 정의 될 때까지 enum의 기본 유형을 완전히 결정할 수 없음을 의미합니다. enum의 선언과 정의를 구분할 수없는 사람은 누구입니까? 따라서 C++에서 enum을 선언 할 수 없습니다.

ISO C++ 표준 S7.2.5 :

열거의 기본 유형은 열거에 정의 된 모든 열거 자 값을 나타낼 수있는 정수 유형입니다. 열거 자의 값이 int 또는 unsigned int에 맞지 않는 한 기본 유형이 int보다 크지 않아야한다는 점을 제외하고 열거의 기본 유형으로 사용되는 정수 유형이 구현 정의되어 있습니다. 열거 자 목록이 비어있는 경우 기본 형식은 열거에 값이 0 인 단일 열거자가있는 것처럼 열거됩니다. sizeof() 값은 열거 유형, 열거 유형의 오브젝트 또는 열거 자에 적용됩니다. sizeof() 값이 기본 유형에 적용됩니다.

sizeof 연산자를 사용하여 C++에서 열거 된 유형의 크기를 결정할 수 있습니다. 열거 된 유형의 크기는 기본 유형의 크기입니다. 이런 식으로 컴파일러가 enum에 사용중인 유형을 추측 할 수 있습니다.

enum 유형을 명시 적으로 다음과 같이 지정하면 어떻게됩니까?

enum Color : char { Red=0, Green=1, Blue=2};
assert(sizeof Color == 1);

그런 다음 enum을 전달할 수 있습니까?

아뇨 그런데 왜 안되죠?

enum의 유형을 지정하는 것은 실제로 현재 C++ 표준의 일부가 아닙니다. VC++ 확장입니다. 그래도 C++ 0x의 일부가 될 것입니다.

소스

30
Brian R. Bondy

[제 답변이 잘못되었지만 의견이 유용하므로 여기에 남겨 두었습니다].

다른 enum 유형에 대한 포인터의 크기가 같지 않으므로 정방향 선언 열거 형은 비표준입니다. 컴파일러는이 유형에 사용할 수있는 크기 포인터를 알기 위해 정의를 볼 필요가 있습니다.

실제로, 적어도 모든 인기있는 컴파일러에서 열거 형에 대한 포인터는 일정한 크기입니다. 예를 들어 열거 형의 선언은 Visual C++에서 언어 확장으로 제공됩니다.

13
James Hopkin

Enum의 전방 선언과 같은 것은 실제로 없습니다. 열거 형 정의에는 열거 형을 사용하는 다른 코드에 의존 할 수있는 코드가 포함되어 있지 않으므로 처음 선언 할 때 열거 형을 완전히 정의하는 것은 일반적으로 문제가되지 않습니다.

열거 형을 전용 멤버 함수로 사용하는 경우 열거 형 자체를 해당 클래스의 전용 멤버로 사용하여 캡슐화를 구현할 수 있습니다. 열거 지점은 선언 시점, 즉 클래스 정의 내에서 여전히 완전히 정의되어야합니다. 그러나 이것은 개인 멤버 함수를 선언하는 것보다 큰 문제는 아니며 구현 내부의 노출을 악화시키는 것은 아닙니다.

구현 세부 사항에 대해 더 깊은 수준의 은폐가 필요한 경우 순수한 가상 함수로 구성된 추상 인터페이스와 인터페이스를 구현하는 구체적이고 완전히 은닉 된 클래스로 분리 할 수 ​​있습니다. 클래스 인스턴스 생성은 팩토리 또는 인터페이스의 정적 멤버 함수로 처리 할 수 ​​있습니다. 그렇게하면 실제 클래스 이름조차도 개인 함수는 물론 노출되지 않습니다.

7
Alexey Feldgendler

실제로 이유는 is enum의 크기가 정방향 선언 후에 아직 알려지지 않았다는 것입니다. 글쎄, 당신은 구조체의 정방향 선언을 사용하여 포인터를 전달하거나 포워드 선언 된 구조체 정의 자체에서 참조되는 곳에서 객체를 참조 할 수 있습니다.

열거 형을 선언하면 값별로 열거 형을 전달할 수 있기 때문에 열거 형을 선언하는 것이 너무 유용하지 않습니다. 최근에 일부 플랫폼에서 int 또는 long보다 char 크기가 다른 포인터를 사용한다고 들었 기 때문에 포인터를 가질 수 없었습니다. 따라서 모두 열거 형의 내용에 달려 있습니다.

현재 C++ 표준은 다음과 같은 작업을 명시 적으로 허용하지 않습니다.

enum X;

(7.1.5.3/1). 그러나 내년으로 인한 다음 C++ 표준은 다음을 허용합니다. 문제는 실제로 기본 유형과 관련이 있음 has

enum X : int;

"불투명 한"열거 선언이라고합니다. 다음 코드에서 X 값 기준을 사용할 수도 있습니다. 그리고 나중에 열거자를 다시 선언하여 열거자를 정의 할 수 있습니다. 현재 작업중인 초안에서 7.2를 참조하십시오.

5

나는 이렇게 할 것입니다 :

[공개 헤더에서]

typedef unsigned long E;

void Foo(E e);

[내부 헤더에]

enum Econtent { FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X,
  FORCE_32BIT = 0xFFFFFFFF };

FORCE_32BIT를 추가하면 Econtent가 오랫동안 컴파일되므로 E와 호환됩니다.

4
Laurie Cheers

GCC에서 앞으로 선언 할 수없는 것 같습니다!

흥미로운 토론 여기

2
prakash

열거자를 구조체로 감싸서 일부 생성자와 형식 변환을 추가하고 구조체를 대신 선언 할 수 있습니다.

#define ENUM_CLASS(NAME, TYPE, VALUES...) \
struct NAME { \
    enum e { VALUES }; \
    explicit NAME(TYPE v) : val(v) {} \
    NAME(e v) : val(v) {} \
    operator e() const { return e(val); } \
    private:\
        TYPE val; \
}

이것은 작동하는 것으로 보입니다 : http://ideone.com/TYtP2

2
Leszek Swirski

열거 형이 헤더 파일에 나타나지 않게하고 개인 방법으로 만 사용되도록하려면 pimpl 원칙을 따르는 것이 좋습니다.

다음과 같이 선언하여 헤더에서 클래스 내부를 숨길 수있는 기술입니다.

class A 
{
public:
    ...
private:
    void* pImpl;
};

그런 다음 구현 파일 (cpp)에서 내부를 나타내는 클래스를 선언합니다.

class AImpl
{
public:
    AImpl(A* pThis): m_pThis(pThis) {}

    ... all private methods here ...
private:
    A* m_pThis;
};

클래스 생성자에서 구현을 동적으로 작성하고 소멸자에서 삭제해야하며 공용 메소드를 구현할 때는 다음을 사용해야합니다.

((AImpl*)pImpl)->PrivateMethod();

Pimpl을 사용하는 장점이 있습니다. 하나는 클래스 헤더를 구현에서 분리하여 하나의 클래스 구현을 변경할 때 다른 클래스를 다시 컴파일 할 필요가 없다는 것입니다. 다른 하나는 헤더가 너무 단순하기 때문에 컴파일 시간을 단축시키는 것입니다.

그러나 사용하기가 어려우므로 열거 형을 헤더에 개인으로 선언하는 것이 큰 문제인지 스스로에게 물어보십시오.

2
Vincent Robert

프로젝트에서 레거시 및 타사 구성 요소의 enums를 처리하기 위해 Namespace-Bound Enumeration 기술을 채택했습니다. 예를 들면 다음과 같습니다.

forward.h :

namespace type
{
    class legacy_type;
    typedef const legacy_type& type;
}

enum.h :

// May be defined here or pulled in via #include.
namespace legacy
{
    enum evil { x , y, z };
}


namespace type
{
    using legacy::evil;

    class legacy_type
    {
    public:
        legacy_type(evil e)
            : e_(e)
        {}

        operator evil() const
        {
            return e_;
        }

    private:
        evil e_;
    };
}

foo.h :

#include "forward.h"

class foo
{
public:
    void f(type::type t);
};

foo.cc :

#include "foo.h"

#include <iostream>
#include "enum.h"

void foo::f(type::type t)
{
    switch (t)
    {
        case legacy::x:
            std::cout << "x" << std::endl;
            break;
        case legacy::y:
            std::cout << "y" << std::endl;
            break;
        case legacy::z:
            std::cout << "z" << std::endl;
            break;
        default:
            std::cout << "default" << std::endl;
    }
}

main.cc :

#include "foo.h"
#include "enum.h"

int main()
{
    foo fu;
    fu.f(legacy::x);

    return 0;
}

foo.h 헤더는 legacy::evil에 대해 아무것도 알 필요가 없습니다. 레거시 유형 legacy::evil (여기서는 main.cc)를 사용하는 파일 만 enum.h를 포함해야합니다.

1
mavam

VC의 경우 forward 선언 및 기본 유형 지정에 대한 테스트가 있습니다.

  1. 다음 코드는 정상적으로 컴파일됩니다.
 typedef int myint; 
 enum T; 
 void foo (T * tp) 
 {
 * tp = (T) 0x12345678; 
} 
 enum T : char 
 {
 A 
}; 

그러나/W4에 대한 경고를 받았습니다 (/ W3은이 경고를 발생시키지 않습니다)

경고 C4480 : 비표준 확장 사용 : 열거 형 'T'에 대한 기본 유형 지정

  1. VC (80x86 용 Microsoft 32 비트 C/C++ 최적화 컴파일러 버전 15.00.30729.01)는 위의 경우 버그로 보입니다.

    • 열거 형 T를 볼 때; VC는 열거 형 T가 기본 유형으로 기본 4 바이트 int를 사용한다고 가정하므로 생성 된 어셈블리 코드는 다음과 같습니다.
? foo @@ YAXPAW4T @@@ Z PROC; foo 
; 파일 e :\work\c_cpp\cpp_snippet.cpp 
; 13 행 
 푸시 ebp 
 mov ebp, esp 
; 14 행 
 mov eax, DWORD PTR _tp $ [ebp] 
 mov DWORD PTR [eax], 305419896; 12345678H 
; 15 행 
 pop ebp 
 ret 0 
? foo @@ YAXPAW4T @@@ Z ENDP; foo 

위의 어셈블리 코드는 내 개인적인 추측이 아니라 /Fatest.asm에서 직접 추출됩니다. mov DWORD PTR [eax], 305419896; 12345678H 라인?

다음 코드 스 니펫이이를 증명합니다.

 int main (int argc, char * argv) 
 {
 union {
 char ca [4]; 
 T t; 
} a; 
 a.ca [0] = a.ca [1] = a. [ca [2] = a.ca [3] = 1; 
 foo (& a. t); 
 printf ( "% # x, % # x, % # x, % # x\n", a.ca [0], a.ca [1], a.ca [2] , a.ca [3]); 
 return 0; 
} 

결과 : 0x78, 0x56, 0x34, 0x12

  • enum T의 정방향 선언을 제거하고 enum T의 정의 다음에 함수 foo의 정의를 이동 한 후 결과는 정상입니다.

위의 키 명령은 다음과 같습니다.

mov BYTE PTR [eax], 120; 00000078H

최종 결과는 0x78, 0x1, 0x1, 0x1입니다.

값을 덮어 쓰지 않습니다.

따라서 VC에서 enum의 선언을 사용하는 것은 해로운 것으로 간주됩니다.

BTW, 놀랍지 않게, 기본 유형의 선언 구문은 C #의 구문과 동일합니다. 실제로는 임베디드 시스템과 대화 할 때 기본 유형을 char로 지정하여 메모리를 제한하는 3 바이트를 절약 할 가치가 있음을 알았습니다.

1
zhaorufei

이것이 충돌 한 이후 몇 가지 반대 의견이 있습니다. 따라서 표준의 관련 비트가 있습니다. 연구에 따르면 표준은 실제로 선언을 정의하지 않으며 열거 형을 전달할 수 없거나 명시 적으로 선언 할 수 없습니다.

먼저 dcl.enum 섹션 7.2에서 :

열거의 기본 유형은 열거에 정의 된 모든 열거 자 값을 나타낼 수있는 정수 유형입니다. 열거 자의 값이 int 또는 unsigned int에 맞지 않는 한 기본 유형이 int보다 크지 않아야한다는 점을 제외하고 열거에 대한 기본 유형으로 사용되는 정수 유형이 구현에서 정의됩니다. 열거 자 목록이 비어있는 경우 기본 형식은 열거에 값이 0 인 단일 열거자가있는 것과 같습니다. sizeof () 값이 열거 형식, 열거 형식의 개체 또는 열거 자에 적용되는 값은 sizeof ()는 기본 유형에 적용됩니다.

따라서 열거 형의 기본 유형은 하나의 사소한 제한으로 구현 정의됩니다.

다음으로 "불완전한 유형"(3.9)에 대한 섹션으로 넘어가겠습니다.이 선언은 앞으로 선언에 대한 표준에 거의 근접합니다.

선언되었지만 정의되지 않은 클래스 또는 알 수없는 크기 또는 불완전한 요소 유형의 배열은 불완전하게 정의 된 객체 유형입니다.

클래스 유형 (예 : "클래스 X")은 번역 단위의 한 시점에서 불완전하고 나중에 완료 될 수 있습니다. "class X"유형은 두 지점에서 동일한 유형입니다. 선언 된 배열 객체 유형은 불완전한 클래스 유형의 배열 일 수 있으므로 불완전합니다. 클래스 유형이 나중에 변환 단위에서 완료되면 배열 유형이 완료됩니다. 이 두 지점의 배열 유형은 동일합니다. 배열 객체의 선언 된 유형은 알 수없는 크기의 배열 일 수 있으므로 변환 단위의 한 시점에서 불완전하며 나중에 완료 될 수 있습니다. 이 두 지점에서의 배열 유형 ( "T의 알 수없는 범위의 배열"및 "N T의 배열")은 다른 유형입니다. 알 수없는 크기의 배열에 대한 포인터 유형 또는 알 수없는 크기의 배열로 typedef 선언에 의해 정의 된 유형의 유형은 완료 할 수 없습니다.

따라서 표준은 앞으로 선언 할 수있는 유형을 거의 배치했습니다. Enum이 없었으므로 컴파일러 작성자는 일반적으로 기본 유형의 가변 크기로 인해 표준에서 허용하지 않는 것으로 선언을 간주합니다.

그것도 말이됩니다. 열거 형은 일반적으로 값별 상황에서 참조되며 실제로 컴파일러는 이러한 상황에서 저장소 크기를 알아야합니다. 스토리지 크기는 구현이 정의되어 있기 때문에 많은 컴파일러는 모든 열거 형의 기본 유형에 32 비트 값을 사용하도록 선택할 수 있습니다.이 시점에서 전달할 수 있습니다. 흥미로운 실험은 Visual Studio에서 열거 형을 선언 한 다음 위에서 설명한대로 sizeof (int)보다 큰 기본 유형을 사용하여 어떤 일이 발생하는지 확인하는 것입니다.

1
Dan Olson

귀하의 문제에 대한 나의 해결책은 다음 중 하나입니다.

1-열거 형 대신 int 사용 : CPP 파일의 익명 네임 스페이스 (int가 아닌)에서 int를 선언하십시오.

namespace
{
   const int FUNCTIONALITY_NORMAL = 0 ;
   const int FUNCTIONALITY_RESTRICTED = 1 ;
   const int FUNCTIONALITY_FOR_PROJECT_X = 2 ;
}

귀하의 방법은 개인 정보이므로 아무도 데이터를 망칠 수 없습니다. 누군가가 잘못된 데이터를 보내면 테스트를 계속할 수도 있습니다.

namespace
{
   const int FUNCTIONALITY_begin = 0 ;
   const int FUNCTIONALITY_NORMAL = 0 ;
   const int FUNCTIONALITY_RESTRICTED = 1 ;
   const int FUNCTIONALITY_FOR_PROJECT_X = 2 ;
   const int FUNCTIONALITY_end = 3 ;

   bool isFunctionalityCorrect(int i)
   {
      return (i >= FUNCTIONALITY_begin) && (i < FUNCTIONALITY_end) ;
   }
}

2 : Java에서와 같이 제한된 const 인스턴스화로 전체 클래스를 만듭니다. 클래스를 전달한 다음 CPP 파일에서 클래스를 정의하고 열거 형 값만 포함하십시오. C++에서 이와 같은 작업을 수행했으며 열거 형을 복사하는 코드 (복사 구성, 연산자 = 등)가 필요했기 때문에 결과가 원하는만큼 만족스럽지 않았습니다.

3 : 앞에서 제안한대로 비공개로 선언 된 열거 형을 사용하십시오. 사용자가 전체 정의를 볼 수는 있지만이를 사용하거나 개인 방법을 사용할 수는 없습니다. 따라서 일반적으로 클래스를 사용하여 코드를 다시 컴파일하지 않고도 기존 메서드의 열거 형과 내용을 수정할 수 있습니다.

내 생각은 해결책 3 또는 1 일 것입니다.

0
paercebal