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입니다.

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

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

열거 의 기본 유형 은 열거에 정의 된 모든 열거 자 값을 나타낼 수있는 정수 유형입니다. 열거 int자의 값이 int또는에 맞지 않는 한 기본 유형이 더 크지 않다는 점을 제외하고 열거에 대한 기본 유형으로 사용되는 정수 유형이 구현 정의되어 있습니다 unsigned int. 는 IF 열거리스트가 비어 열거의 값은 0 값을 가진 단일 열거 한 것처럼 기본 유형이 sizeof()열거 타입 열거 타입의 객체 또는 열거인가를,의 값 sizeof()에인가는 기본 유형.

때문에 호출자 함수에 올바르게 설정에 호출 스택을 매개 변수의 크기를 알고 있어야합니다, 열거 목록에 열거의 수는 함수 프로토 타입을 알아야합니다.

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

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

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.

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

스토리지 유형을 동시에 선언하는 한 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라는 제안이 있습니다.

C ++로 선언하는 것은 컴파일 시간을 크게 단축 시키므로 매우 유용합니다 . 당신은 앞으로 포함한 C의 몇 가지를 ++ 선언 할 수있다 : struct, class, function, 등 ...

그러나 enumC ++로 선언 할 수 있습니까?

아뇨.

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

잘못된.

C ++에는 enumC # (int)에있는 것과 같은 기본 유형이 없습니다 . C ++에서 당신의 enum타입은 컴파일러에 의해 당신이 가진 값의 범위에 맞는 타입으로 결정될 것 enum입니다.

그게 무슨 뜻이야?

그것은 당신의 것을 의미 enum당신의 모든 값이 될 때까지 '기본 s의 형식이 완전히 확인할 수 없습니다 enum정의합니다. 어떤 마르스 당신이 당신의 선언과 정의를 분리 할 수 있습니다 enum. 따라서 enumC ++로 선언을 전달할 수 없습니다 .

ISO C ++ 표준 S7.2.5 :

열거의 기본 유형은 열거에 정의 된 모든 열거 자 값을 나타낼 수있는 정수 유형입니다. 열거 int자의 값이 int또는에 맞지 않는 한 기본 유형이 더 크지 않다는 점을 제외하고 열거에 대한 기본 유형으로 사용되는 정수 유형이 구현 정의되어 있습니다 unsigned 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의 일부가 될 것입니다.

출처

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

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

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

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

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

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

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

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

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

enum X;

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

enum X : int;

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

나는 이렇게 할 것입니다 :

[공개 헤더에서]

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와 호환됩니다.

열거 형이 헤더 파일에 나타나지 않게하고 개인 방법으로 만 사용되도록하려면 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을 사용하는 장점이 있습니다. 하나는 클래스 헤더를 구현에서 분리하여 하나의 클래스 구현을 변경할 때 다른 클래스를 다시 컴파일 할 필요가 없다는 것입니다. 다른 하나는 헤더가 너무 단순하기 때문에 컴파일 시간을 단축시키는 것입니다.

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

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

#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

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

여기서 흥미로운 토론

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

먼저 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)보다 큰 기본 유형을 사용하여 어떤 일이 발생하는지 확인하는 것입니다.

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

1. 다음 코드는 정상적으로 컴파일됩니다.

    typedef int myint;
    열거 형 T;
    무효 foo (T * tp)
    {
        * tp = (T) 0x12345678;
    }
    열거 형 T : char
    {
        ㅏ
    };

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

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

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

   • 열거 형 T를 볼 때; VC는 열거 형 T가 기본 유형으로 기본 4 바이트 int를 사용한다고 가정하므로 생성 된 어셈블리 코드는 다음과 같습니다.

    ? foo @@ YAXPAW4T @@@ Z PROC; 푸
    ; 파일 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 호선
        팝 ebp
        리트 0
    ? foo @@ YAXPAW4T @@@ Z ENDP; 푸

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

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

    int main (int argc, char * argv)
    {
        노동 조합 {
            숯 ca [4];
            T t;
        }ㅏ;
        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]) ;
        리턴 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 바이트를 절약 할 가치가 있음을 알았습니다.

내 프로젝트에서는 레거시 및 타사 구성 요소의을 처리하기 위해 네임 스페이스 바운드 열거 기술을 채택했습니다 enum. 예를 들면 다음과 같습니다.

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-열거 형 대신 int를 사용하십시오. 헤더가 아닌 CPP 파일의 익명 네임 스페이스에서 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 일 것입니다.

열거 형은 다양한 크기의 정수 크기가 될 수 있기 때문에 (컴파일러는 주어진 열거 형의 크기를 결정합니다) 열거 형의 포인터는 정수 유형이기 때문에 다양한 크기를 가질 수 있습니다 (문자는 일부 플랫폼에서 다른 크기의 포인터를 갖습니다) 예를 들어).

따라서 컴파일러는 열거 형과 사용자에게 포인터를 전달할 수조차 없습니다. 거기에서도 열거 형의 크기가 필요하기 때문입니다.

유형 요소의 가능한 값을 제한된 세트로 제한하기 위해 열거를 정의합니다. 이 제한은 컴파일 타임에 적용됩니다.

나중에 '제한된 세트'를 사용할 것이라는 사실을 선언 할 때 아무런 가치가 추가되지 않습니다. 후속 코드는 가능한 값을 알아야 이점을 얻을 수 있습니다.

컴파일러 는 열거 유형의 크기에 대해 우려 하지만 열거 선언 할 때 열거 의도 가 손실됩니다.