C++에서 열거형 선언 전달
https://stackoverflow.com/questions/71416
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
나는 다음과 같은 일을하려고합니다 :
enum E;
void Foo(E e);
enum E {A, B, C};
컴파일러가 거부하는 것입니다.Google에서 잠깐 살펴보니 "당신은 할 수 없다"는 합의가 있는 것 같은데 왜 그런지 이해할 수 없습니다.누구든지 설명할 수 있나요?
설명 2:나는 열거형을 취하는 클래스에 개인 메소드가 있고 열거형의 값이 노출되는 것을 원하지 않기 때문에 이 작업을 수행하고 있습니다. 예를 들어 E가 다음과 같이 정의되어 있다는 것을 누구에게도 알리고 싶지 않습니다.
enum E {
FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X
}
프로젝트 X는 사용자가 알기를 원하는 것이 아니기 때문입니다.
그래서 나는 헤더 파일에 개인 메소드를 넣고, cpp에서 내부적으로 열거형을 선언하고, 빌드된 라이브러리 파일과 헤더를 사람들에게 배포할 수 있도록 열거형을 전달하고 싶었습니다.
컴파일러는 GCC입니다.
해결책
열거형을 전방 선언할 수 없는 이유는 값을 모르면 컴파일러가 열거형 변수에 필요한 저장 공간을 알 수 없기 때문입니다.C++ 컴파일러는 지정된 모든 값을 포함하는 데 필요한 크기를 기반으로 실제 저장 공간을 지정할 수 있습니다.보이는 것이 전방 선언뿐이라면 번역 단위는 어떤 저장소 크기가 선택될지 알 수 없습니다. 이는 char, int 또는 다른 것일 수 있습니다.
ISO C++ 표준의 섹션 7.2.5에서:
그만큼 기본 유형 열거형은 열거형에 정의된 모든 열거자 값을 나타낼 수 있는 정수 유형입니다.기본 유형이 다음보다 클 수 없다는 점을 제외하고 어떤 정수 유형이 열거형의 기본 유형으로 사용되는지는 구현에 따라 정의됩니다.
int열거자의 값이int또는unsigned int.만약 열거자 목록 비어 있으면 기본 유형은 열거형에 값이 0인 단일 열거자가 있는 것과 같습니다.의 가치sizeof()열거형, 열거형 개체 또는 열거자에 적용되는 값은 다음과 같습니다.sizeof()기본 유형에 적용됩니다.
이후 방문객 함수가 호출 스택을 올바르게 설정하려면 매개변수의 크기를 알아야 하며, 열거 목록의 열거 수는 함수 프로토타입보다 먼저 알려져야 합니다.
업데이트:C++0X에서는 열거형 유형을 전방으로 선언하는 구문이 제안되고 승인되었습니다.다음에서 제안을 볼 수 있습니다. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf
다른 팁
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.
최근 개발 상황을 고려하여 여기에 최신 답변을 추가하고 있습니다.
저장 유형을 동시에 선언하는 한 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, 등...
하지만 앞으로 선언할 수 있나요? enum C++에서?
아니요, 그럴 수 없습니다.
그런데 왜 허용하지 않는 걸까요?그것이 허용된다면 당신은 당신의 enum 헤더 파일을 입력하고 enum 소스 파일의 값.허용되어야 할 것 같죠?
잘못된.
C++에는 기본 유형이 없습니다. enum C#(int)에 있는 것과 같습니다.C++에서는 enum 유형은 컴파일러에 의해 사용자가 가지고 있는 값의 범위에 맞는 유형으로 결정됩니다. enum.
그게 무슨 뜻이에요?
그것은 당신의 enum의 기본 유형은 의 모든 값을 얻을 때까지 완전히 결정될 수 없습니다. enum 한정된.당신의 선언과 정의를 분리할 수 없는 사람은 누구입니까? enum.따라서 선언을 전달할 수 없습니다. enum C++에서.
ISO C++ 표준 S7.2.5:
열거형의 기본 형식은 열거형에 정의된 모든 열거자 값을 나타낼 수 있는 정수 계열 형식입니다.기본 유형이 다음보다 클 수 없다는 점을 제외하고 어떤 정수 유형이 열거형의 기본 유형으로 사용되는지는 구현에 따라 정의됩니다.
int열거자의 값이int또는unsigned int.열거자 목록이 비어 있으면 기본 유형은 열거에 값이 0인 단일 열거자가 있는 것과 같습니다.의 가치sizeof()열거형, 열거형 개체 또는 열거자에 적용되는 값은 다음과 같습니다.sizeof()기본 유형에 적용됩니다.
다음을 사용하여 C++에서 열거형 유형의 크기를 결정할 수 있습니다. sizeof 운영자.열거된 유형의 크기는 기본 유형의 크기입니다.이 방법으로 컴파일러가 어떤 유형을 사용하고 있는지 추측할 수 있습니다. enum.
유형을 지정하면 어떻게 되나요? enum 명시적으로 다음과 같습니다:
enum Color : char { Red=0, Green=1, Blue=2};
assert(sizeof Color == 1);
그런 다음 앞으로 선언할 수 있습니까? enum?
아니요.그런데 왜 안되죠?
유형 지정 enum 실제로는 현재 C++ 표준의 일부가 아닙니다.VC++ 확장입니다.하지만 C++0x의 일부가 될 것입니다.
[제 답변이 틀렸지만 댓글이 도움이 되서 여기에 남깁니다.]
열거형을 전방으로 선언하는 것은 비표준입니다. 다른 열거형 유형에 대한 포인터가 동일한 크기라고 보장되지 않기 때문입니다.컴파일러는 이 유형에 사용할 수 있는 포인터 크기를 알기 위해 정의를 확인해야 할 수도 있습니다.
실제로, 적어도 널리 사용되는 모든 컴파일러에서는 열거형에 대한 포인터의 크기가 일정합니다.예를 들어 열거형의 전방 선언은 Visual C++에서 언어 확장으로 제공됩니다.
실제로 enum의 전방 선언과 같은 것은 없습니다.열거형의 정의에는 열거형을 사용하는 다른 코드에 의존할 수 있는 코드가 포함되어 있지 않으므로 처음 선언할 때 열거형을 완전히 정의하는 것은 일반적으로 문제가 되지 않습니다.
열거형의 유일한 사용이 전용 멤버 함수에 의한 것이라면 열거형 자체를 해당 클래스의 전용 멤버로 하여 캡슐화를 구현할 수 있습니다.열거형은 선언 시점, 즉 클래스 정의 내에서 완전히 정의되어야 합니다.그러나 이는 비공개 멤버 함수를 선언하는 것보다 더 큰 문제가 아니며 구현 내부를 노출하는 것보다 더 나쁜 것은 아닙니다.
구현 세부 사항에 대해 더 깊은 수준의 은폐가 필요한 경우 이를 순수 가상 함수로만 구성된 추상 인터페이스와 인터페이스를 구현(상속)하는 구체적이고 완전히 숨겨진 클래스로 나눌 수 있습니다.클래스 인스턴스 생성은 팩토리 또는 인터페이스의 정적 멤버 함수에 의해 처리될 수 있습니다.이렇게 하면 개인 기능은 물론 실제 클래스 이름도 노출되지 않습니다.
실제로 그 이유를 지적하면 ~이다 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가 long으로 컴파일되므로 E와 상호 교환이 가능합니다.
GCC에서는 앞으로 선언할 수 없는 것 같습니다!
흥미로운 토론 여기
열거형이 헤더 파일에 표시되는 것을 원하지 않고 개인 메서드에서만 사용되도록 하려면 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
이것이 충돌한 이후로 약간의 반대 의견이 있으므로 여기에 표준의 관련 내용이 있습니다.연구에 따르면 표준은 실제로 전방 선언을 정의하지 않으며 열거형을 전방 선언할 수 있는지 여부를 명시적으로 명시하지도 않습니다.
먼저 dcl.enum 섹션 7.2에서 다음을 수행합니다.
열거의 기본 유형은 열거에 정의 된 모든 열거 자 값을 나타낼 수있는 적분 유형입니다.열거 자의 값이 int 또는 서명되지 않은 INT에 맞지 않는 한 기본 유형이 int보다 크지 않아야한다는 점을 제외하고는 열거의 기본 유형으로 사용되는 적분 유형이 구현 정의됩니다.열거 자 목록이 비어있는 경우, 기본 유형은 열거에 값 0을 갖는 단일 열거자가있는 것처럼 보인다.열거 유형, 열거 유형의 객체 또는 열거 자에 적용되는 sizeof ()의 값은 기본 유형에 적용되는 sizeof ()의 값입니다.
따라서 열거형의 기본 유형은 구현에 따라 정의되며 한 가지 사소한 제한 사항이 있습니다.
다음으로 "불완전한 유형"(3.9) 섹션으로 넘어갑니다. 이는 전방 선언에 대한 표준에 거의 근접합니다.
선언되었지만 정의되지 않은 클래스 또는 알 수없는 크기 또는 불완전한 요소 유형의 배열은 불완전하게 정의 된 객체 유형입니다.
클래스 유형 (예 : "클래스 X")은 번역 장치의 한 지점에서 불완전하고 나중에 완료 할 수 있습니다."class X" 유형은 두 지점 모두에서 동일한 유형입니다.선언 된 배열 객체의 유형은 불완전한 클래스 유형의 배열 일 수 있으므로 불완전 할 수 있습니다.클래스 유형이 번역 장치에서 나중에 완료되면 배열 유형이 완료됩니다.두 지점의 배열 유형은 동일한 유형입니다.배열 객체의 선언 된 유형은 알려지지 않은 크기의 배열 일 수 있으므로 번역 장치의 한 지점에서 불완전하고 나중에 완료 할 수 있습니다.이 두 지점에서 배열 유형 ( "알 수없는 t의 배열"및 "NT 배열"은 다른 유형입니다.알 수없는 크기의 배열에 대한 포인터 유형 또는 typedef 선언에 의해 알려지지 않은 크기의 배열로 정의 된 유형의 유형은 완료 될 수 없습니다.
따라서 표준에서는 앞으로 선언할 수 있는 유형을 거의 명시했습니다.Enum이 없었기 때문에 컴파일러 작성자는 일반적으로 기본 유형의 가변 크기로 인해 표준에서 허용되지 않는 전방 선언을 간주합니다.
그것도 의미가 있습니다.열거형은 일반적으로 값으로 참조되며, 컴파일러는 실제로 이러한 상황에서 저장소 크기를 알아야 합니다.저장소 크기는 구현에 따라 정의되므로 많은 컴파일러는 모든 열거형의 기본 유형에 대해 32비트 값을 사용하도록 선택할 수 있으며, 이 시점에서 해당 값을 전달 선언하는 것이 가능해집니다.흥미로운 실험은 Visual Studio에서 열거형을 선언한 다음 위에서 설명한 대로 sizeof(int)보다 큰 기본 형식을 사용하도록 강제하여 무슨 일이 일어나는지 확인하는 것입니다.
VC의 경우 전방 선언 및 기본 유형 지정에 대한 테스트는 다음과 같습니다.
- 다음 코드는 정상적으로 컴파일되었습니다.
typedef int myint;
enum T ;
void foo(T * tp )
{
* tp = (T)0x12345678;
}
enum T : char
{
A
};
하지만 /W4(/W3에는 이 경고가 발생하지 않음)에 대한 경고가 표시됩니다.
경고 C4480:비표준 확장이 사용됨:열거형 'T'에 대한 기본 유형 지정
VC (80x86의 경우 Microsoft (R) 32 비트 C/C ++ 최적화 15.00.30729.01) 위의 경우 버그가 나타납니다.
- 열거형 T를 볼 때;VC는 열거형 T가 기본 4바이트 int를 기본 유형으로 사용한다고 가정하므로 생성된 어셈블리 코드는 다음과 같습니다.
?foo@@YAXPAW4T@@@Z PROC ; foo
; File e:\work\c_cpp\cpp_snippet.cpp
; Line 13
push ebp
mov ebp, esp
; Line 14
mov eax, DWORD PTR _tp$[ebp]
mov DWORD PTR [eax], 305419896 ; 12345678H
; Line 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
- 열거형 T의 전방 선언을 제거한 후 함수 foo의 정의를 열거형 T의 정의 뒤로 이동합니다.결과는 괜찮습니다.
위의 주요 명령은 다음과 같습니다.
mov BYTE PTR [eax], 120 ;00000078H
최종 결과는 다음과 같습니다0x78, 0x1, 0x1, 0x1
값을 덮어쓰지 않습니다.
따라서 VC에서 enum의 전방 선언을 사용하는 것은 해로운 것으로 간주됩니다.
그런데 놀랍게도 기본 유형의 선언 구문은 C#의 구문과 동일합니다.실제로 메모리가 제한된 임베디드 시스템과 통신할 때 기본 유형을 char로 지정하여 3바이트를 절약하는 것이 가치가 있다는 것을 알았습니다.
내 프로젝트에서 나는 다음을 채택했습니다. 네임스페이스 바인딩된 열거형 대처하는 기술 enum레거시 및 타사 구성 요소에서 가져온 것입니다.예는 다음과 같습니다.
앞으로.h:
namespace type
{
class legacy_type;
typedef const legacy_type& type;
}
열거형.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;
}
}
메인.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 또는 1이 될 것입니다.
열거형은 다양한 크기의 정수 크기일 수 있기 때문에(컴파일러는 주어진 열거형의 크기를 결정함) 열거형에 대한 포인터도 정수 유형이므로 다양한 크기를 가질 수 있습니다(문자는 일부 플랫폼에서 다른 크기의 포인터를 가짐) 예를 들어).
따라서 컴파일러는 열거형을 전달 선언하고 사용자가 이에 대한 포인터를 갖도록 할 수도 없습니다. 거기에서도 열거형의 크기가 필요하기 때문입니다.
유형 요소의 가능한 값을 제한된 세트로 제한하기 위해 열거형을 정의합니다.이 제한은 컴파일 타임에 적용됩니다.
나중에 '제한된 세트'를 사용할 것이라는 사실을 앞으로 선언해도 아무런 가치가 추가되지 않습니다.후속 코드는 이를 활용하려면 가능한 값을 알아야 합니다.
비록 컴파일러 ~이다 열거된 유형의 크기에 관심이 있는 경우 의지 열거형을 선언하면 해당 열거형이 손실됩니다.
