'2016/03'에 해당되는 글 9건

2016.03.30 p12 인증서를 하드디스크에 넣기 1
2016.03.27 rtsp url
2016.03.27 [펌] FFMPEG: Can not free AVPacket when decode H264 stream?
2016.03.27 av_free_packet 예제들
2016.03.27 [펌] ffmpeg - rtmp sample 테스트 (rtsp도 포함)
2016.03.26 [펌] How to: Debug from a DLL Project
2016.03.26 [펌] c++ dll (/clr) 을 c#에서 dllimport 하고 디버그(debug) 하기
2016.03.10 [펌] 효과적인 C# 메모리 관리 기법
2016.03.07 [펌] pragma에 관한 사용법

RSS Reader Extension (by Inoreader) (0)	2020.12.24
코카콜라 캔은 냉동실에 넣으면 폭발 위험 있음. (0)	2014.08.23
070전화 wifi 비번 (0)	2014.04.22

VLC Player로 RTSP 영상 보는 방법 (TCP or UDP) (0)	2016.04.04
[펌] 풀 덤프 파일을 남기는 방법 (0)	2016.02.25
The Windows Programming Model (0)	2015.12.19

[펌] FFMPEG: Can not free AVPacket when decode H264 stream?

Programming/C++ 2016. 3. 27. 06:54

AVPacket 해제에 대한 글

출처 : http://stackoverflow.com/questions/26090992/ffmpeg-can-not-free-avpacket-when-decode-h264-stream

av_free_packet will clear your packet data, the same pointer that was allocated inside av_read_frame. But you changed it in packet.data += bytesDecoded; => crash.

Several advices:

No need to call av_init_packet if the first use of your packet is av_read_frame (it is done inside this function). But if you keep your code, you need it in order to initialize packet.size to 0 (tested, but not initialized the first time)
Call av_free_packet each time you are done with the packet data, only when the decode is successful. In your code, it means you must call it after avcodec_decode_video2, even if the frame is not finished.
Once your packed is decoded (i.e. avcodec_decode_video2 is ok, no matter if frameFinished is true or false), you can free it. No need to keep it and change data pointer. The process is "read packet, decode it, free it. read next packet, decode it, free it.". (Note that this does not apply to audio packets).

I suggest simplify your main loop by something like (read first, decode after):

while(true)
{
    // Step 1: Read packet
    while(true)
    {
        av_read_frame(pFormatCtx, &packet);

        // todo: Error handling

        if(packet.stream_index != videoStreamIndex)
        {
            av_free_packet(&packet);
        }
        else
        {
            break;
        }
    } while (packet.stream_index != videoStreamIndex);

    // Step 2/3: Decode and free
    avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
    av_free_packet(&packet);

    // todo: Error handling and checking frameFinished if needed
    // Of course, if you need to use the packet now, move the av_free_packet() after this
}

저작자표시 비영리 변경금지

'Programming > C++' 카테고리의 다른 글

[펌] Visual Studio에서 프로그램이 끝나고 콘솔 창 유지하기 (0)	2016.05.26
av_free_packet 예제들 (0)	2016.03.27
[펌] ffmpeg - rtmp sample 테스트 (rtsp도 포함) (0)	2016.03.27

Posted by 세모아

[펌] FFMPEG: Can not free AVPacket when decode H264 stream? (0)	2016.03.27
[펌] ffmpeg - rtmp sample 테스트 (rtsp도 포함) (0)	2016.03.27
[펌] How to: Debug from a DLL Project (0)	2016.03.26

[펌] ffmpeg - rtmp sample 테스트 (rtsp도 포함)

Programming/C++ 2016. 3. 27. 06:31

출처: http://bluexmas.tistory.com/273

av_free_packet 예제들 (0)	2016.03.27
[펌] How to: Debug from a DLL Project (0)	2016.03.26
[펌] pragma에 관한 사용법 (0)	2016.03.07

[펌] How to: Debug from a DLL Project

Programming/C++ 2016. 3. 26. 13:25

출처: https://msdn.microsoft.com/ko-kr/library/605a12zt(v=vs.120).aspx

Visual Studio 2013 대상

How to: Debug from a DLL Project

To specify the calling application in a C++ project

In Solution Explorer, select the DLL project.
On the View menu, choose Property Pages.
In the ProjectProperty Pages window, in the Configuration drop-down list, choose Debug.
Open the Configuration Properties folder, and select the Debugging category.
In the Debugger to launch list, choose Local Windows Debugger or Remote Windows Debugger.
In the Command or Remote Command box, click the drop-down arrow, and select Browse from the list to locate the application.Alternatively, type the path and name of the application.
Type any necessary program arguments in the Command Arguments box.

To specify the calling application in a C# or Visual Basic project

In Solution Explorer, select the DLL project.
On the View menu, choose Property Pages.
In the ProjectProperty Pages window, in the Configuration drop-down list, choose Debug.
Click the Debug tab.
You can start the application by either doing the following:
1. Set the Start Action to Start external program.
2. In the Start external program box, click the ellipsis button to browse for the application.
3. Enter any necessary program arguments in the Command Line Arguments box.
Or, you can invoke an application at a URL. (You might want to do this if you are debugging a managed DLL used by a local ASP.NET application.)
1. Under Start Action, select the Start browser in URL: radio button.
2. In the adjoining text box, type the URL.

To start debugging from the DLL project

In Solution Explorer, select the DLL project.
Set breakpoints as needed.
Enter the name and location of the calling application in the ProjectProperty Pages dialog box or window. If the application is a console application, fill in the command line arguments, if it is necessary.

저작자표시 비영리 변경금지

'Programming > C++' 카테고리의 다른 글

[펌] ffmpeg - rtmp sample 테스트 (rtsp도 포함) (0)	2016.03.27
[펌] pragma에 관한 사용법 (0)	2016.03.07
[펌] C++ DebugView로 디버그 메시지 보기 (0)	2015.05.13

Posted by 세모아

[펌] c++ dll (/clr) 을 c#에서 dllimport 하고 디버그(debug) 하기

Programming/C# 2016. 3. 26. 13:16

출처: http://sjc333.egloos.com/3131382

c++ dll (/clr) 을 c#에서 dllimport 하고 디버그(debug) 하기

by 오린간
2015/01/28 17:00
sjc333.egloos.com/3131382
덧글수 : 0

제목이 좀 어렵네요.

그냥 이쪽 전공에서나 필요한 지식이고, 귀찮으니 최대한 요점만 짧게 로그 남기듯이 적습니다.

보통은 이런 뻔한 시나리오는 안적는데 vs2013의 황당한 버그 비슷한 것이 저를 괴롭혀서 2시간 가량 낭비하는 바람에

저와 같은 피해자(?)가 없도록 글을 남기는 것입니다. ㅎㅎ

1. C++ dll을 만든다. 이때 clr 옵션을 건다. 자세한건 구글링...

한줄만 더 적자면 CLR은 managed가 아니다.

2. C# 어플리케이션을 만들고 1에서 만든 dll을 .cs 소스코드 안에서 직접 import. 하고 작동되는지 확인한다.

ex ) [DllImport("../bin/test.dll")]

이 글을 보는 사람이라면 사실 1과 2는 이미 되어있는 상태일 것이라고 가정함.

3. 이제 셋팅 들어간다. 위의 1, 2는 하나의 솔루션에 있어야 한다.

- 가장 중요한 것!! tools > options > debugging > general > 마지막줄의 use managed compatibility mode 체크.

- 솔루션에 속성 설정 > common properties > project dependencies > 여기서 c# 프로젝트는 c++ dll 프로젝트에 의존한다고 체크

- c#프로젝트에 속성 설정 > debug > Enable Debuggers > Enable native code debugging 체크!!!

- c#프로젝트를 set as startup project

4. 이제 준비는 끝났으니 c++ 코드에 브레이크 포인트 걸고 F5

3번에 중요하다고 한 부분이 내가 고생한 부분이다. 인터넷에서 c++ dll을 c#에서 로드하는 상황에서 디버깅하는 방법을 검색해봤는데 저 말을 찾을 수 없었다. 어딘가 누군가는 적어놨겠지만...아무튼 저 부분이 매우 중요하다.

만약에 use managed com... 이 것을 체크하지 않은 상태라면 이상한 현상이 발생한다.

- enable native code... 이 옵션을 체크하면 c++에 브레이크 포인트가 작동하지 않는다.

- enable native code... 이 옵션을 해제하면 c++에 브레이크 포인트가 작동은 하지만 변수값을 제대로 볼 수 없다.

그런데 인터넷에서 흔히 찾을 수 있는 글들에는 오히려 enable native code... 를 해제하면 브레이크 포인트를 쓸 수 없다는 식으로 설명하기 때문에 굉장히 혼란스럽다.

아마도 vs2013의 사소한 버그인듯...

다행인 것은 c#에서 c++ dll을 로드한 상태로 디버깅을 시도하면 use managed com... 이 옵션을 켜야한다고 메세지가 뜬다.

문제는 이 메세지가 제법 길기 때문에 실수로 확인버튼 눌러서 닫으면 옵션이 어디에 있는지 찾기 힘들다는 것.

나는 대충 읽고 옵션을 찾으려고 했는데 tools에서 안찾고 c#프로젝트에서 찾아 들어가는 바람에 ....그 때 부터 대혼란이 시작되었다 orz

저작자표시 비영리 변경금지

'Programming > C#' 카테고리의 다른 글

[펌] 효과적인 C# 메모리 관리 기법 (0)	2016.03.10
C#에서 윈도우 서비스 실행폴더 알아내기 (0)	2016.02.24
C# delegate & event 작성순서- 20150604 (0)	2015.10.21

Posted by 세모아

[펌] 효과적인 C# 메모리 관리 기법

Programming/C# 2016. 3. 10. 00:18

출처: http://blog.daum.net/silnoontee/13743552

*** 출처: 마이크로소프트웨어

*** 링크: 효과적인 C#메모리 기법

조명근 narlamy@ndoors.net｜엔도어즈 기술 지원팀 팀장으로 근무하고 있으며, MMORPG ‘아틀란티카’를 개발했다. 덴마크에 있는 유니티 개발팀과 긴밀히 협조해 메모리 문제 등 여러 가지 이슈들을 처리하고 있으며 현재 유니티 3D엔진을 사용해 웹과 모바일 플랫폼을 지원하는 MMORPG ‘삼국지를 품다’를 개발하고 있다.

C#은 상당히 좋은 언어다. 가장 많이 알려진 C#의 특징 중 하나는 메모리 관리에 부담이 없다는 점이다.

So Cool~ C# 메모리
C/C++를 사용하면서 포인터 때문에 괴로워 해본 적이 있는가? 그렇다면 C#에 관심을 가져보는 것이 좋다. C#은 다음과 같은 특징들을 제공하기 때문이다.

- 메모리 해제에 신경 쓰지 않아도 된다.
- 이미 삭제된 메모리에 접근하는 실수를 방지해준다.
- 잘못된 캐스팅으로 엉뚱한 메모리에 접근하지 않게 한다.
- 배열 크기보다 큰 메모리에 접근하지 못한다.
- 메모리 단편화에 대해 신경 쓰지 않아도 된다.

편한 C#, 마구잡이로 사용하면 낭패
골치 아픈 메모리 관리를 신경 쓰지 않아도 된다는 점은 사용자들에게 무척 편리하게 다가온다. 하지만 C#에서도 메모리를 다루기 위해서는 세심한 주의가 필요하다. 마음 놓고 개발하다 당황했던 과거 필자의 경험을 살펴보도록 하자.

개 발 초창기, 게임 플레이 중에 주기적으로 랙이 발생했다. 로직을 확인해 봤지만 특별히 로딩 중이거나 초기화된 부분이 없어 의아했다. 유니티 엔진에서 제공하는 프로파일러로 한 프레임에 걸리는 시간을 측정해봤다. 측정 결과, System.GC.Collect() 호출에 오랜 시간이 걸린다는 점이 발견됐다. 플레이 중에 프레임마다 소모되는 시간을 그래프로 보여주는 <그림 1>을 보면 System.GC.Collect() 호출 시 그래프가 크게 튀어 오른 모습이 확인된다. C#에서 사용하지 않는 메모리를 정리하면서 가비지 컬렉션(Garbage collection) 랙이 발생한 것이다.

<그림 1> 프로파일러 이미지

이때는 가비지 컬렉션이 동작하는 횟수를 줄여서 랙 발생을 줄이면 된다. 가비지 발생을 줄이면 가비지 컬렉션이 호출되는 시간을 늦출 수 있어 동작 횟수가 줄어든다. 가비지란 프로그램이 실행되면서 어디에서든 더 이상 참조되지 않는 메모리를 의미하므로 가능한 한 메모리를 할당했다 금방 버려지는 상황을 만들지 않는 것이 좋다. 몇 가지 사례들을 살펴보자.

‘+’ operator를 통한 문자열 조합
C#은 문자열 조합이 쉽다. <리스트 1>에 보이는 것처럼 ‘+’로 연결하면 간단히 문자열 조합이 이뤄진다. 모든 객체가 ToString()을 지원하기 때문에 문자열끼리만 조합되는 게 아니라 int, float 등의 값도 알아서 문자열로 변환·조합된다.

<리스트 1> ‘+’로 연결한 문자열 조합

class Names
{
    public string[] name = new string[100];
    public void Print()
    {
        for (int index = 0; index < name.Length; index++)
        {
            string output = "[" + index + "]" + name;
            Console.WriteLine(output);
        }
    }
}

문제는 <리스트 1>에서 가비지가 많이 발생한다는 점이다. ‘+’ 연산자로 두 값을 연결할 때마다 새로운 string 인스턴스가 생성된다. 연이어 ‘+’ 연산자가 나오기 때문에 다시금 새로운 string 인스턴스가 생성되고, 이전에 만들어진 string 인스턴스는 가비지가 된다. string 조합을 위해 ‘+’ operator 호출이 많아질수록 많은 가비지가 만들어지는 것이다.

그래서 문자열을 조합하는 동안 새로운 객체를 생성하지 않는 System.Text.StringBuilder 객체를 소개한다. ‘+’ operator가 아닌 Append() 메소드를 통해 문자열을 추가하며, string 객체를 만들어내는 게 아니라 이미 잡아놓은 메모리 공간에 문자열만 복사해 뒀다가 한번에 ToString()으로 string 객체를 생성해낸다.

<리스트 2> System.Text.StringBuilder 객체 사용

class NewNames
{
public string[] name = new string[100];
private StringBuilder sb = new StringBuilder();

    public void Print()
    {
        sb.Clear();     // sb.Length = 0;
        for (int index = 0; index < name.Length; index++)
        {
            sb.Append("[");
            sb.Append(index);
            sb.Append("] ");
            sb.Append(name);
            sb.AppendLine();
        }
        Console.WriteLine(sb.ToString());
    }
}

과다한 Append() 메소드 호출이 필요해 ‘+’ 코드보다 깔끔하지 못하다고 생각된다면 AppendFormat()을 사용하는 것도 좋다.

<리스트 3> AppendFormat() 활용

class NewNames
{
public string[] name = new string[100];
private StringBuilder sb = new StringBuilder();

    public void Print()
    {
        sb.Clear();     // sb.Length = 0;
        for (int index = 0; index < name.Length; index++)
        {
            sb.AppendFormat("[{0}] {1}", index, name.ToString());
        }
        Console.WriteLine(sb.ToString());
    }
}

string처럼 Immutable pattern을 사용한 객체들의 값에 접근할 때는 기존 메모리를 수정하지 않고 새로운 메모리를 만들어 반환하거나 입력받으므로 사용 시 주의가 필요하다.

메소드 안에서 생성한 객체
C#은 C++과 달리 클래스를 인스턴싱하려면 반드시 new를 해줘야 한다. 이때 heap에서 메모리 할당이 일어난다.

<리스트 4>와 같이 메소드 안에서 new로 생성된 인스턴스는 메소드를 빠져나오면 더 이상 사용하지 않게 돼 가비지로 처리된다. 이런 패턴의 메소드가 자주 호출될수록 가비지도 많이 발생한다.

<리스트 4> new로 생성된 인스턴스

public class MyVector
{
    public float x, y;
    public MyVector(float x, float y) { this.x = x; this.y = y; }
    public double Length() { return System.Math.Sqrt(x * x + y * y); }
}

static class TestMyVector
{
    public static void PrintVectorLength(float x, float y)
    {
        MyVector v = new MyVector(x, y);
        Console.WriteLine("Vector=({0},{1}), lenght={2}", x, y, v.Length());
    }
}

Vector 클래스를 구조체로 바꿔보면, new 연산자로 인스턴스를 만들어도 heap 영역에 메모리가 할당되지 않는다. 구조체 역시 Value type이기 때문에 stack 영역에 메모리가 할당되며, 메소드를 빠져나갈 경우 자동으로 삭제된다. 물론 heap 영역에 생성된 메모리가 아니기 때문에 가비지 컬렉션의 대상이 되지도 않는다.

<리스트 5> Vector 클래스를 구조체로 변환

public struct MyVector
{
    public float x, y;
    public MyVector(float x, float y) { this.x = x; this.y = y; }
    public double Length() { return System.Math.Sqrt(x * x + y * y); }
}

구조체로 바꿀 수 없다면, <리스트 6>처럼 멤버변수 사용을 권장한다.

<리스트 6> 멤버변수 사용

public class MyVector
{
    public float x, y;
    public MyVector() { x = .0f; y = .0f; }
    public MyVector(float x, float y) { this.x = x; this.y = y; }
    public double Length() { return System.Math.Sqrt(x * x + y * y); }
}

static class TestMyVector
{
    private static MyVector m_cachedVector = new MyVector();
    public static void PrintVectorLength(float x, float y)
    {
        m_cachedVector.x = x;
        m_cachedVector.y = y;

Console.WriteLine("Vector=({0},{1}), lenght={2}",
x, y, m_cachedVector.Length());
}
}

속도 저하가 큰 Boxing
Boxing이란 Value type 객체를 Reference type 객체로 포장하는 과정을 뜻한다. C#의 모든 객체는 object로부터 상속되는데, 심지어 상속받지 못하는 int, float 등의 Value type 조차도 object로부터 상속된 것처럼 사용할 수 있다. 하지만 가비지 컬렉션에 의한 부하 못지않게 boxing으로 인한 부하도 크다. 무심코 만든 코드에서 boxing 과정이 일어나는 경우가 있으니 잘 이해하고 사용해야 한다.

<리스트 7>을 보면 리스트에 서로 다른 type의 값을 추가했지만, loop 안에서 추가 값을 object type으로 받아 하나의 코드로 처리할 수 있음을 알 수 있다.

<리스트 7> 서로 다른 type 값 추가

class MyClass
{
public override string ToString() { return "다섯"; }

    static public void Sample()
    {
        ArrayList list = new ArrayList();
        list.Add(1);
        list.Add(1.5f);
        list.Add(‘3’);
        list.Add("four");
        list.Add(new MyClass());

        foreach (object item in list)
            Console.WriteLine(item.ToString());
    }
}

<그림 2> <리스트 7>의 실행 결과

매력적인 C#이지만 Value type의 값을 Reference type인 object로 바꿔주는 과정에는 많은 시간이 걸리며 변환 시에는 System.Object 내부에 랩핑하고 관리되는 heap에 저장된다. 즉 새로운 객체가 만들어지는 셈이다. MSDN에서 발췌한 <그림 3>을 참조하길 바란다.

https://msdn.microsoft.com/ko-kr/library/yz2be5wk.aspx

http://www.gamedevforever.com/322

<그림 3> boxing과 unboxing의 비교

따라서 한 번에 다양한 type을 처리하는 경우가 아니라면 collection에 사용된 값의 type을 명시해주는 Generic collection 사용을 권한다. Generic은 C++의 template와 비슷하다. 그래서 Generic collection들은 C++의 STL container들과 비슷하게 생겼다. <리스트 8>을 참고하자.

<리스트 8> Generic collection

class Example
{
    static public void BadCase()
    {
        ArrayList list = new ArrayList();
        int evenSum = 0;
        int oddSum = 0;

for (int i = 0; i < 1000000; i++)
list.Add(i);

        foreach (object item in list)
        {
            if (item is int)
            {
                int num = (int)item;
                if(num % 2 ==0) evenSum += num;
                else oddSum += num;
            }
        }

        Console.WriteLine("EvenSum={0}, OddSum={1}", evenSum, oddSum);
    }

    static public void GoodCase()
    {
        List<int> list = new List<int>();
        int evenSum = 0;
        int oddSum = 0;

for (int i = 0; i < 1000000; i++)
list.Add(i);

        foreach (int num in list)
        {
            if (num % 2 == 0) evenSum += num;
            else oddSum += num;
        }

        Console.WriteLine("EvenSum={0}, OddSum={1}", evenSum, oddSum);
    }
}

메모리가 계속 늘어나는 또 다른 문제의 발생!
이 글을 시작하며 C#에서 사용자는 메모리 해제에 신경 쓸 필요가 없다고 했지만 의도하지 않게 메모리가 늘어나기도 한다. C#에는 delete 같은 메모리 해제 명령이 없기에 메모리 릭(memory leak) 현상이 발생하면 당혹스러울 수 있다. 여기서 C# 메모리의 특징을 다시 한 번 떠올려보자.

시스템에서 더 이상 참조가 없는 메모리를 알아서 해제하는 것을 우리는 가비지 컬렉션이라 부른다. 가비지는 더 이상 참조가 없는 메모리다. C# 애플리케이션이 메모리가 해제되지 않고 계속 증가되고 있다면 어디선가 의도하지 않는 참조가 일어나고 있다고 보면 된다. 그렇다면 어디에서 의도하지 않은 참조가 일어나는 것일까? 예를 통해 확인해 보자.

<그림 4> #1 - 케릭터 매니저에서 케릭터를 생성한다

<그림 5> #2 - 누군가 디버깅을 위해 '캐릭터 위치 표시' 객체를 만들고 캐릭터 매니저에 접근해 등록된 캐릭터를 모두 참조한다

<그림 6> #3 - 캐릭터 매니저에서 필요없는 캐릭터를 삭제한다

<그림 7> #4 - 캐릭터 매니저에서 삭제됏지만 '캐릭터 위치 표시' 객체에서는 여전히 참조 중이다. 가비지가 아니기 때문에 메모리에 계속 남아있으며, 구현에 따라서는 의도하지 않게 화면에 남을 수도 있다.

WeakReference로 의도하지 않은 참조를 없애보자
System.WeakReference 는 가비지 컬렉션에 의한 객체 회수를 허용하면서 객체를 참조한다. 인스턴스를 참조하려면 Weak Reference.Target으로 접근해야 하는데 원본 인스턴스가 가비지 컬렉터에 의해 회수되면 WeakReference.Target은 null이 반환된다.

<리스트 9> WeakReference.Target

public class Sample
{
    private class Fruit
    {
        public Fruit(string name) { this.Name = name; }
        public string Name { private set; get; }
    }

    public static void TestWeakRef()
    {
        Fruit apple = new Fruit("Apple");
        Fruit orange = new Fruit("Orange");

        Fruit fruit1 = apple;   // strong reference
        WeakReference fruit2 = new WeakReference(orange);
        Fruit target;

        target = fruit2.Target as Fruit;
        Console.WriteLine(" (1) Fruit1 = \"{0}\", Fruit2 = \"{1}\"",
            fruit1.Name, target == null ? "" : target.Name);

apple = null;
orange = null;

System.GC.Collect(0, GCCollectionMode.Forced);
System.GC.WaitForFullGCComplete();

        // fruit1과 fruit2의 값을 바꾼 적은 없지만, fruit2의 결과가 달라진다.
        target = fruit2.Target as Fruit;
        Console.WriteLine(" (2) Fruit1 = \"{0}\", Fruit2 = \"{1}\"",
            fruit1==null ? "" : fruit1.Name,
            target == null ? "" : target.Name);
    }
}

<리스트 9>의 실행으로 <그림 8>을 확인할 수 있다. Fruit2가 참조하고 있던 orange 인스턴스는 가비지 컬렉터에 의해 회수돼 null이 됐다.

<그림 8> <리스트 9>의 실행 결과

‘캐릭터 매니저’처럼 객체의 생성·삭제를 직접 관여하는 모듈이 아닌 곳에서는 가능한 WeakRefernce를 사용하는 것이 좋다. ‘객체 위치 표시 객체’처럼 인스턴스를 참조하는 모듈에서 WeakReference를 사용하면, 의도하지 않은 참조로 메모리가 해제되지 않는 실수를 방지할 수 있다. 주의할 점은 Weak Reference.Target 값을 보관하면 안 된다는 것이다. 만약 그대로 보관하고 있으면 강한 참조(strong reference)가 일어나 이를 인식한 가비지 컬렉터는 회수를 실행하지 않게 된다.

C/C++처럼 원하는 시점에 객체를 삭제하고 싶다면
C#에서 는 할당된 메모리를 임의로 해제할 수 없다. 컬렉션에 보관된 인스턴스를 제거하거나 인스턴스를 담고 있던 변수에 null을 넣어 더 이상 참조하지 않는 방법이 있지만 실제 인스턴스가 삭제되는 시점은 가비지 컬렉션 동작 이후가 되므로, 언제가 될 지 정확히 알 수 없다. 의도한 시점에 맞춰 정확히 삭제할 수 없다는 점이 그렇게 중요하지는 않다. 하지만 캐릭터 매니저에서 캐릭터를 제거했는데도 여전히 캐릭터 인스턴스가 남아서 화면에 한동안 계속 나타나는 경우가 발생할 수 있다.

Dispose pattern 소개C#에서는 관리되지 않는 메모리(리소스)를 해제하는 용도로 System.IDisposable이라는 인터페이스를 제공한다. IDisposable 인터페이스를 상속받은 클래스라면 용도에 맞게 Dispose()를 구현해줘야 하는데 이는 FileStream 관련 객체들에서 많이 볼 수 있다.

리소스를 강제로 해제시키려면 직접 Release(), Delete(), Destroy(), Close() 등의 메소드를 만들어 사용하면 되는데 굳이 IDisposable을 사용할 필요가 있을까? 서로 다른 type의 객체여도 IDisposable 인터페이스를 상속받고 있다면, 하나의 코드로 다양한 type의 메모리를 정리할 수 있기 때문에 IDisposable을 사용할 필요가 있다. 또한 Dispose() 메소드만 보고도 “아, 이 클래스는 사용이 끝나면 Dispose()를 호출해서 메모리를 정리해야 하는구나” 라고 금방 알 수 있다.

캐릭터 객체에서 IDisposable 인터페이스를 구현해보자. 업데이트 목록에서도 제외시키고 렌더링 정보도 다 지우자. 캐릭터의 Dipsose()를 호출한 이후에 캐릭터는 어떠한 동작도 하지 못하게 된다. 물론 Dispose()를 호출한다고 캐릭터가 가비지 컬렉터에 의해 메모리 해제되는 것은 아니다.

WeakReference과 IDisosalbe의 조합원하는 시점에 메모리를 해제하려면 앞서 설명한 Weak Reference와 IDisposable을 개별적으로 사용하는 것으로는 부족하다. 둘을 함께 사용하는 것이 좋다. <리스트 10>을 보자.

<리스트 10> Disposable 인터페이스를 상속받아 구현된 캐릭터 클래스

namespace MyApp
{
    public class SampleChar : IDisposable
    {
        private IRenderObject m_Render = Renderer.CreateRenderObject();

        public void Dispose()
        {
            SampleCharManager.Remove(this);
            m_Render = null;
        }

public bool isRemoved { get { return m_Render == null; } }

        public void Render()
        {
            if (m_Render == null) return;
            // 렌더링
        }

public void Update() { }
}
}

예제로 만들어 본 캐릭터 클래스는 Disposable 인터페이스를 상속받아 구현된다. Dispose 후에는 더 이상 업데이트가 되지 않도록 SampleCharManager에서 제거되며, 렌더링 객체를 null로 만들어 화면에 그려지지 않도록 했다.

IRenderObject 인터페이스는 <리스트 11>과 같이 구현된다.

<리스트 11> IRenderObject 인터페이스

namespace MyApp
{
    public interface IRenderObject
    {
        void Render();
    }

    public static class Renderer
    {
        public static IRenderObject CreateRenderObject()
{
return new DumyRenderObject(); // IRenderObject를 상속받은 더미 객체
}
    }
}

<리스트 12>의 캐릭터 매니저 클래스는 등록된 캐릭터들을 일괄적으로 업데이트시키고 렌더링한다.

<리스트 12> 등록 캐릭터 일괄 업데이트 및 렌더링

namespace MyApp
{
    static class SampleCharManager
    {
        private static List<SampleChar> m_list = new List<SampleChar>();

        public static void Update()
        {
            foreach (SampleChar obj in m_list)
                obj.Update();
        }

        public static void Render()
        {
            foreach (SampleChar obj in m_list)
                obj.Render();
        }

        public static void Add(SampleChar obj)
        {
            m_list.Add(obj);
        }

        public static void Remove(SampleChar obj)
        {
            m_list.Remove(obj);
        }
    }
}

<리스트 13>의 디버깅을 위한 ‘캐릭터 위치 표시 객체’는 WeakReference를 통해 SampleChar 객체를 참조하도록 구현돼 있고, SampleCharManager에서 캐릭터를 삭제하더라도 안전하게 가비지가 회수된다. 업데이트 시 DisplayCharInfo는 삭제된 캐릭터를 스스로 판단해 목록에서 제거한다.

<리스트 13> 디버깅을 위한 캐릭터 위치 표시 객체

namespace MyDebug
{
    static class DisplayCharInfo
    {
        private static List<WeakReference> m_list = new List<WeakReference>();
        private static Queue<WeakReference> m_removeQueue =
new Queue<WeakReference>();

        public static void Update()
        {
            foreach (WeakReference item in m_list)
            {
                MyApp.SampleChar obj = (item.Target != null) ?
item.Target as MyApp.SampleChar : null;

                if (obj == null || obj.isRemoved)
                {
                    m_removeQueue.Enqueue(item);
                }
                else
                {
                    /* 캐릭터 정보 표시 */
                }
            }

            while(m_removeQueue.Count > 0)
            {
                WeakReference item = m_removeQueue.Dequeue();
                m_list.Remove(item);
            }
        }

        public static void Add(MyApp.SampleChar obj)
        {
            m_list.Add(new WeakReference(obj));
        }
    }
}

C#에서 메모리를 관리하는 데 도움되길 바라며, 지금까지 설명한 내용을 요약하면 다음과 같다.

- string 조합이 많다면, StringBuilder 활용
- Immutable 객체의 값 접근 시 매번 메모리가 생성될 수 있으므로 주의
- 매번 호출되는 메소드 안에서 반복해서 일회성 인스턴스가 생성되지 않도록 주의
- Boxing / unboxing이 가능한 일어나지 않도록 주의
- WeakReference를 사용해서 의도하지 않은 참조 줄이기
- IDisposable 인터페이스를 사용해 사용자가 원하는 시점에 객체 삭제하기

Value type과 Reference type 비교

Value type은 stack 영역에 할당되며 값이 통째로 복사된다.

유니티 3D엔진에서의 메모리 관리
유니티 3D엔진으로 개발하면서 주의할 내용을 알아보자. 유니티 3D엔진은 크게 모노 메모리와 엔진에서 관리하는 메모리로 나뉜다. 둘 다 메모리가 부족하면 내부에 관리하는 heap 영역을 늘려 메모리를 할당한다. 이렇게 한 번 늘어난 heap은 줄어들지 않는 특징을 가진다. 물론 늘어난 heap 안에서 메모리가 재사용되므로, 무턱대고 늘어나진 않는다. 하지만 가비지를 너무 많이 생성시키면 GC.Collect()로 인한 성능저하와 더불어 최대 메모리가 늘어날 수도 있으니 주의해야 한다. 가능한 가비지가 덜 생성되도록 코드를 구현하는 게 좋다. 메모리는 한 번에 잡는 것이 좋고, caching이나 memory pool을 사용하는 것도 도움이 된다.

<리스트 14> Value typepublic static class Sample
{
    public static void TestValueType()
    {
        int a = 100;
        int b = a;

        a = 200;
        Console.WriteLine(" a={0}, b={1}", a, b);
    }
}

<리스트 14>를 실행하면 <그림 9>와 같은 결과를 확인할 수 있다. a와 b는 서로 다른 메모리 공간을 가지고 있다.

<그림 9> <리스트 14>의 실행 결과

Reference Type은 heap 영역에 할당되며, C/C++의 포인터나 레퍼런스처럼 new로 생성한 인스턴스를 참조한다.

<리스트 15> Reference type

public class MyInt
{
public int Value { get; set; }
public MyInt(int val) { this.Value = val; }

    public static void TestReferenceType()
    {
        MyInt a = new MyInt(100);
        MyInt b = a;

        a.Value = 200;
        Console.WriteLine(" a={0}, b={1}", a.Value, b.Value);
    }
}

<리스트 15>의 실행 결과로 <그림 10>을 확인할 수 있다. a와 b는 같은 메모리를 참조한다.

<그림 10> <리스트 15>의 실행 결과

저작자표시 비영리 변경금지

'Programming > C#' 카테고리의 다른 글

[펌] c++ dll (/clr) 을 c#에서 dllimport 하고 디버그(debug) 하기 (0)	2016.03.26
C#에서 윈도우 서비스 실행폴더 알아내기 (0)	2016.02.24
C# delegate & event 작성순서- 20150604 (0)	2015.10.21

Posted by 세모아

[펌] pragma에 관한 사용법

Programming/C++ 2016. 3. 7. 10:36

아래 내용중에서 필요한 것은,

#pragma comment()

이 중 가장 대표적인 사용법은 명시적인 라이브러리의 링크이다.

#pragma comment(lib, "xxxx.lib")

와 같이 사용하여 해당 라이브러리를 링크시켜 준다.
여러사람이 같이 수행하는 프로젝트의 경우 이와 같은 방법을 사용하여 lib를 링크하는 것이 라이브러리가 링크되어있다는 사실을 알기에도 좋고 굳이 주석다라 설명할 필요도 없어 좋지 않나 싶다. (있다는 사실은 알지만 아직 프로젝트 수행중 실제로 사용해 본적은 없음)

굳이 project settings에서 link tab에 있는 input에 .lib file을 쓰지 않고 #pragma comment ( lib, "xxx.lib" ) 라고 써도 된다는 거죠..

My)

아래그림과 같이 Linker의 Additional Library Directories에 lib파일이 있는 경로에 포함시키고,

cpp파일에 #pragma comment(lib, "avformat.lib")

을 기록한다.

참고 : http://oojjrs.tistory.com/35 (#pragma comment(lib, file) 에 임의의 상대경로 입력하기)

출처: http://iprinceps.egloos.com/1334766

매번 매번 사용해도 헷갈리는 pragma의 용법에 대해 모아 총정리 하였다.

#pragma는 define 이나 include와 같이 #으로 시작하는 전처리구문(precompiler)의 하나이다.
컴파일러에 종속적인 구문이라 컴파일러가 변경되었을 경우 제대로된 동작을 보장하지 못하므로 프로젝트 진행중에 서로 다른 컴파일러를 사용한다면 사용하지 않음이 바람직 하겠다.
- 대신 대체하는 문법을 사용해야 되겠다.

#pragma once
이것은 "컴파일러에게 한번만 컴파일해!" 라고 명령한다.
헤더의 중복을 막아준다.
무슨말인가 하면

a.h를 구현한 a.cpp, a.h는 독립적이다.(include가 없다.)
b.h를 구현한 b.cpp, c.h, a.h순서로 include
c.h를 구현한 c.cpp, a.h를 include

컴파일하면 b.h에서 c.h를 포함시키라고 되어있네? 하고 c.h에 들어가고 어? a.h를 포함하라고 그러네? 이러고 a.h를 포함한 c.h가 b.h로 돌아온다 그리고 a.h를 포함하라는 명령을 받고 a.h를 추가하다보면 같은 변수와 함수선언이 되어있다. 에러에러~
같은 선언이 두 번 반복되니 당연히 충돌이 난다. 컴파일러가 똑똑하여 단순히 경고 처리만 해주고 알아서 하나로 종합해줄 수도 있지만 대부분의 기본적인 컴파일러는 이건 아니잖아~ 한다.

이럴 때 써주는 것이다. pragma once
이는 c기본문법을 사용하여 구현할 수 있다.

#ifdef _MYCOMPILECK
#define _MYCOMPILECK
// 헤더 파일의 내용 선언
#endif

#pragma comment()
기본적인 pragma comment()의 형식은 다음과 같다.

#pragma comment( comment-type, ["comment string"] )

[] 안의 구문은 comment-type에 따라 필요할 경우 사용하는 것이다.
comment type에는 compiler, exestr, lib, linker, user 등이 올 수 있다.

#pragma comment( linker, "/subsystem:windows" )
#pragma comment( linker, "/subsystem:console" )

linker 를 사용하면 프로젝트를 console application인지 win32 application인지 명시해줄 수 있다.

또한 섹션의 설정을 할 수 있다.

#pragme comment( linker, "SECTION:.SHAREDATA,RWS" )

#pragma data_seg("SHAREDATA") 와 함께 사용하여 공유 메모리를 생성한다.
위의 명령어 대신 def 파일 안에 아래와 같이 해주어도 된다.

SECTIONS
SHAREDATA READ WRITE SHARED

이 중 가장 대표적인 사용법은 명시적인 라이브러리의 링크이다.

#pragma comment(lib, "xxxx.lib")

와 같이 사용하여 해당 라이브러리를 링크시켜 준다.
여러사람이 같이 수행하는 프로젝트의 경우 이와 같은 방법을 사용하여 lib를 링크하는 것이 라이브러리가 링크되어있다는 사실을 알기에도 좋고 굳이 주석다라 설명할 필요도 없어 좋지 않나 싶다. (있다는 사실은 알지만 아직 프로젝트 수행중 실제로 사용해 본적은 없음)

#pragma data_seg()
pragma data_seg()의 형식은 다음과 같다.

#pragma data_seg( ["section-name"[, "section-class"] ] )

[]는 사용하지 않아도 된다는 의미이다.

#pragma data_seg( "SHAREDATA" )
int x;
char y;
#pragma data_seg()

DLL 파일을 만들어보면서 제일 많이 사용해 보았고 가장 헷갈려 했던 부분이기도 하다.
DLL의 데이터 공유를 하기 위해 사용한다.
공유할 섹션을 만드는 것이다. 위의 명령어는 필수적으로 위에서 사용된 두 가지중 한가지 방법과 함께 사용 되어야 한다.

#pragme comment( linker, "SECTION:.SHAREDATA,RWS" )

SECTIONS
SHAREDATA READ WRITE SHARED

둘 다 해당 SECTION(SHAREDATA)의 허용 범위(?속성?)를 설정하는 것이다. READ, WRITE, SHARED 세 가지를 쓴다는 의미~
해당 사항에 대해 msdn에서 자세한 정보를 발견하지 못해 적지 못하였다(검색능력의 부족!!)
이제 변수 x와 y는 해당 dll을 사용하는 외부 파일과 같이 공유할 수 있는 변수가 되었다.(외부에서 접근 가능하게 되었다.)

이렇게 공유하는 변수는 물론 new로 메모리를 할당한 변수도 공유 가능하다.
특히 new 나 memalloc(이건 아직 미확인이지만 같은 메모리 할당이므로 가능할 것으로 본다)으로 메모리할당한 변수들은 dll외부에서도 해제(delete) 가능하다.

#pragma warning
특정 경고를 끄고 싶을 때 사용한다.
비쥬얼 스튜디오의 버전이 다르기 때문에 뜨는 경고는 더더욱이 귀찮은 존재이다.(하지만 수정해서 손해볼 것은 없다. 그것이 곧 버그로 이어질 수 있기 때문이다. 특히 형변환의 경우 강제 캐스팅하여 확실히 명시해주는 것이 좋다. 일부러 그 값을 떼어낸다는 프로그래머의 의지를 컴파일러에게 보여주자. 부지런할수록 후에 손이 가는 일이 적어진다. 노력하자~)

형식은 이와 같다.

#pragma warning( warning-specifier : warning-number-list [; warning-specifier : warning-number-list...] )
#pragma warning( push[ ,n ] )
#pragma warning( pop )

실제 사용은 아래와 같이 한다.

#pragma warning( disable:4996 )

#pragma message()
컴파일 중에 메세지를 뿌려준다.
말이 필요없다-.-/

#pragma message("merong")

Takes from: http://mayu.tistory.com/8

선행처리기중의 하나인 pragma에 관한 사용법을 정리하여 올립니다.
문법은 다음과 같습니다.

#pragma directive-name

#pragma는 이것을 지원하는 다른 compiler에서 방해가 없이 C++ Builder에서 원하는
지시어를 정의할 수 있도록 해줍니다. 만일 지시명을 인식하지 못한다면 에러 또는
경고 메세지를 수반하지 않고서 #pragma의 지시를 무시하게 됩니다.

Borland C++ Builder에서 지원하는 #pragma지시어는 모두 18가지가 있습니다.
이제부터 그것들을 하나 하나 살펴보기로 하겠습니다.

1. #pragma anon_struct
    . 사용법
      #pragma anon_struct on
      #pragma anon_struct off
    . Class에 익명의 구조체를 포함하여 compile하는것을 허락할 것인지를
      지시합니다. 익명이란 tag를 갖지 않는다는것을 의미합니다.
    ex)
    #pragma anon_struct on
    struct S {
       int i;
       struct { // 익명구조체를 포함한다.
          int   j ;
          float x ;
       };
       class { // 익명 클래스를 포함한다.
       public:
          long double ld;
       };
    S() { i = 1; j = 2; x = 3.3; ld = 12345.5;}
    };
    #pragma anon_struct off

    void main() {
       S mystruct;
       mystruct.x = 1.2; // 포함된 data에 값을 할당한다.
   }

//--------------------------------------------------------------------------
2. #pragma argsused
    . argsused 프라그마는 함수 정의 사이에서만 허용되고 바로 다음 함수에만
      영향을 미치며 경고 메세지를 disable시킵니다.
      이 pragma를 사용하지 않은 경우 사용되지 않은 argument가 있으면
      "Parameter name is never used in function func-name"
      라는 경고 메세지를 표시하게 됩니다.
    ex)
    #pragma argsused
    void __fastcall TImageForm::FileEditKeyPress(TObject* Sender, Char &Key)
    {     if (Key == 0x13) {
             FileListBox1->ApplyFilePath(FileEdit->Text);
             Key = 0x0;
          }
    }
    위의 예에서는 함수내에서 Sender라는 인수가 사용되지 않았지만 경고 메세지가
    표시되지 않습니다.

//--------------------------------------------------------------------------
3. #pragma codeseg
    . 사용법
      #pragma codeseg <seg_name> <"seg_class"> <group>
    . codeseg 프라그마는 함수들을 위치시킬 group, class 또는 segment의 이름을
      줄수 있도록 지시합니다. 만일 option없이 사용하였다면 함수의 배치를 위해서
      default code segment가 사용되어질것입니다. 결국 이 pragma를 사용하지 않는
      경우와 동일한 결과를 가져옵니다.

//--------------------------------------------------------------------------

4. #pragma comment
    . 사용법
      #pragma comment (comment type, "string")
    . comment 프라그마는 출력되어지는 file에 주석을 기록시킬것을 지시합니다.
      comment type에 올수 있는 값들은 다음중의 하나가 될것입니다.
      * exestr
        linker가 ".OBJ" file에 string을 기록합니다. 이렇게 기록된 string은
        실행파일내부에 기록되어지며, 이것은 결코 메모리로 load되지 않습니다.
        하지만 적당한 파일 검색 유틸리티를 사용하여 실행파일에서 string을
        찾아볼 수 있습니다.
      * lib
        ".OBJ" file에 주석의 내용을 기록합니다.
        library에 새로운 module을 추가하는 경우 에만 comment 프라그마를 사용하여
        linker에게 결과 file에 명시할 수 있도록 지시할 수 있습니다. 다시 말하면
        기존에 작성되어진 module에는 comment 프라그마를 사용하여 string을 추가
        시킬수 없습니다. 새롭게 library를 작성한다면 예외일 수 있겠지요.
        linker는 최종의 library에서 string에 명시된 library module 이름을 포함
        합니다. 여러개의 module들도 이름지어질 수 있으며 이름을 만들기 위하여
        linke되어집니다.

예) comment ( lib, * ) : comment로 사용할 수 있는 명령은 여러 개 있는데, 그중 가장 대표적인 것이 lib 으로, 해당 라이브러리를 링크시켜준다 .

즉, 지정된 라이브러리 화일을 포함하여 컴파일한다. 프로젝트 설정에 라이브러리를 포함하는 것과 같다.

        예2) comment( lib, "ws2_32" )
              이것은, 컴파일시 ws2_32.lib 파일을 링크하라는 명령입니다. 보통 Visual studio같은
              IDE 개발환경에서는, 프로젝트 셋팅에서 해주지만, 혹 그런부분을 빼먹거나 환경이
              바뀔때를 대비해서 이렇게 해두면 편하죠.

예3) #pragma comment( "comment-type" [, commentstring] )

comment type에는 compiler, exestr, lib, linker, user 등이 올 수 있습니다.

그 중 질문에서의 lib는 library file을 지정하는 것이라고 생각하시면 됩니다. comment string이라는 부분에는 file의 이름이나 path를 넣으시면 됩니다. ".lib" file 아시죠?

그러니까 굳이 project settings에서 link tab에 있는 input에 .lib file을 쓰지 않고 #pragma comment ( lib, "xxx.lib" ) 라고 써도 된다는 거죠..

      * user
        compiler는 ".OBJ" file에 string을 기록합니다. 하지만 linker에 의해
        string은 무시되어집니다. object 파일에만 그 내용이 남게 됩니다.

//--------------------------------------------------------------------------

5. #pragma exit
    . 사용법
      #pragma startup function-name <priority>
      #pragma exit function-name <priority>
    . 이들 두 프라그마는 프로그램이 프로그램 시동시(main이 호출되기 전) 호출
      되어야 할 함수와 프로그램 탈출(프로그램이 _exit를 통해 종료하기 바로 전)
      을 명시할 수 있도록 합니다. 명시된 function-name은 반드시 인수를 취하지
      않고 void를 return하는 미리 선언된 함수여야합니다. 다시 말하면 다음과
      같이 선언될 수 있습니다.
      void func (void);
      priority는 반드시 64-255의 범위 내에 있는 정수여야하며 최상의 우선권은
      0입니다. 0-63사이의 priority는 C library에서 사용하므로 사용자가 이를
      사용해서는 안됩니다. 최상위 우선권을 가진 함수는 시동시에 맨 먼저 호출
      되고 탈출시에 맨 마지막으로 호출됩니다. 우선권을 명시해 주지 않을 경우
      기본적으로 100의 우선권을 갖게 됩니다. pragma startup 또는 exit에 사용된
      함수명은 반드시 프라그마 라인에 도달하기 전에 정의(또는 선언)되어야함에
      주의하십시요.
    ex)
      #include <stdio.h>
      void startFunc(void)
      {
          printf("Startup Function.\n");
      }
      #pragma startup startFunc 64 //우선권 64로 시동시에 맨 먼저 호출됩니다.

      void exit Func(void)
      {
          pirntf("Wrapping up execution.\n");
      }
      #pragma exit exitFunc //기본적으로 우선권이 100으로 지정됩니다.

      void main(void)
      {
          printf("This is main.\n");
      }

//--------------------------------------------------------------------------

6. #pragma hdrfile
    . 사용법
      #pragma hdrfile "filename.CSM"
    . 이 지시어는 프리컴파일된 헤더를 저장할 파일의 이름을 설정합니다. IDE
      프로젝트를 위한 디폴트 파일명은 <projectname>.CSM이고 command line용
      으로는 BC32DEF.CSM이라는 이름을 갖습니다. 프리컴파일된 헤더를 사용하지
      않으면 이 지시어는 효력이 없으며 명령라인 컴파일러 옵션 -H=filename 또는
      프리 컴파일된 헤더를 사용하면 프리 컴파일된 헤더를 저장하기 위해 사용되는
      파일명을 변경할 수 있습니다.
      명령라인 옵션은 다음과 같습니다.
      * 프리컴파일드 헤더를 사용하는 경우
        -H=filename
      * 프리컴파일드 헤더를 사용은 하지만 새로운 프리컴파일드 헤더파일을
        변환하지 않는 경우
        -Hu
      * 프리컴파일드 헤더를 사용하지 않거나 새로운 프리컴파일드 헤더파일을
        변환하지 않는 경우. (기본값)
        -H-

//--------------------------------------------------------------------------

7. #pragma hdrstop
    . 사용법
      #pragma hdrstop
    . 이 지시어는 프리컴파일에 적합한 헤더 파일의 목록을 종료시키는데, 이것을
      사용하면 프리컴파일된 헤더가 사용하는 디스크 공간의 양을 줄일 수 있습니다.
      프리컴파일드 헤더파일은 #pragma hdrstop이 선언되기 전에 #include를
      사용하여 포함된 헤더파일들을 동일하게 프로젝트 내의 source들간에 공유시킬
      수 있습니다. 그러므로 #pragma hdrstop전에 일반적인 헤더파일들을 포함하면
      최상의 콤파일러의 성능을 얻을 수 있습니다. 확실하게 #pragma hdrstop 전에
      #include를 사용한다면 모든 source file들에게 동일하게 적용되거나 아주
      조그마한 변화만이 있을 것입니다. IDE 환경에서는 강화된 프리컴파일드 헤더의
      성능을 가지는 코드로 변환합니다. 예를 들자면 다음의 New Application의 소스
      파일인 "Unit1.cpp"는 다음과 같이 될것입니다.

#include <vcl.h> // 일반적인 헤더파일
#pragma hdrstop // 헤더파일의 리스트는 여기서 끝난다.

      #include "Unit1.h" // 헤더파일의 명시
      //....
      이 pragma 지시어는 오직 source file에서만 사용하며, 헤더파일에서 사용했다
      면 아무런 효과도 없을 것입니다.

//--------------------------------------------------------------------------

8. #pragma inline
    . 사용법
      #pragma inline
    . 이 지시어는 명령 라인 콤파일러 옵션 -B 또는 IDE의 인라인 옵션과 동일
      합니다. 이것은 컴파일러에게 프로그램 내에 인라인 어셈블리 언어 코드가
      있음을 알려줍니다. 컴파일러는 #pragma inline을 만날때 -B옵션을 사용하여
      스스로 재시동하므로 이 지시어는 파일의 상단에 배치되는 것이 최선입니다.
      실제로 -B옵션과 #pragma inline을 모두 off시켜둘 수 있습니다. 그러면
      컴파일러는 asm문을 만나자마자 스스로 재시동합니다. 이 옵션과 지시어의
      목적은 컴파일 시간을 다소 절약하는 것입니다.

//--------------------------------------------------------------------------

9. #pragma intrinsic
    . 사용법
      #pragma intrinsic [-]function-name
    . #pragma intrinsic를 사용하면 함수의 inline화를 위해 command-line 스위치나
      IDE의 옵션이 무시되어집니다. intrinsic함수를 인라인화할 때는 그 함수를
      사용하기 전에 반드시 그것을 위한 원형을 포함시켜야만 합니다. 이것은
      인라인화 할 때 컴파일러가 인라인화한 함수를 내부적으로 인식하는 함수로
      개명하는 매크로를 실제로 생성하기 때문입니다. 가령 strcpy 함수를 인라인
      화 하기 위하여 다음과 같은 문장을 사용하였다면
      #pragma intrinsic strcpy
      컴파일러는 다음과 같은 매크로를 생성합니다.
      #define strcpy __strcpy__
      컴파일러는 두 선행 밑줄과 두 후미 밑줄을 사용하여 함수 호출을 인식하고
      그 함수의 원형을 내부적으로 저장해 둔 원형과 부합시키려 합니다. 그러므로
      원형을 공급하지 않거나 공급한 원형이 콤파일러 내부의 원형과 부합되지 않을
      경우, 콤파일러는 그 함수를 인라인화 하려는 시도를 불식시키고 에러를
      발생시킵니다. 이 프라그마 사용의 궁극적인 목적은 함수 호출에 대한
      오버헤드를 줄위기 위한것입니다. 함수호출은 빨라지겠지만 그만큼 크기는
      증가하게 될것입니다.
      ex)
      #pragma intrinsic strcpy
      #pragma intrinsic -strcpy

//--------------------------------------------------------------------------

10.#pragma link
    . 사용법
      #pragma link "[path]modulename[.ext]"
    . 이 지시어는 실행화일에 파일을 링크시킬것을 링커에세 지시합니다.
      기본적으로 링커는 -L옵션으로 지정된 패스와 로칼 디렉토리에서 modulename을
      찾습니다. path 아규먼트를 이용하여 디렉토리를 지정할 수도 있습니다. 또한
      링커는 확장자를 ".obj"를 기본으로 간주합니다.

//--------------------------------------------------------------------------

11. #pragma message

     컴파일 도중에 지정된 내용을 VC의 아웃풋 윈도우에 출력시켜 준다. 컴파일시 특정 문장을 표시
    . 사용법
      #pragma message ("text" ["text"["text" ...]])
      #pragma message text
    . #pragma message는 프로그램 코드 내에서 사용자 정의 메세지를 명시합니다.
      첫번째 형식은 하나 이상의 스트링 상수들로 구성된 문장을 필요로 하고
      메세지는 괄호안에 싸여있어야만 합니다.(이 형식은 MSC와 호환됩니다.)
      두번째 형식은 경고 메세지의 문장을 위해 #pragma에 연속되는 문장을
      사용합니다. #pragma의 두가지 형태와 함께 다른 메크로의 참조는 메세지가
      디스플레이 되기전에 확장되어집니다. 사용자 정의 메세지가 디스플레이
      되는것은 기본치이며 명령 라인 옵션의 Show Warnings를 사용하여
      on/off 시킬 수 있습니다. 이 옵션은 콤파일러의 -wmsg에 해당합니다.

    ex)
      // msacm.h
      #if defined(UNICODE) && !defined(_UNICODE)
      #ifndef RC_INVOKED
      #pragma message("MSACM.H: defining _UNICODE
                       because application defined UNICODE")
      #endif
      #define _UNICODE
      #endif

      // ustring.h
      #pragma message osl/ustring.h has been replaced by winsys/string.h
      #include <winsys/string.h>

//--------------------------------------------------------------------------

12.#pragma obsolete
    . 사용법
      #pragma obsolete identifier
    . #pragma obsolete 프로그램 코드에서 pragma의 선언 이후에 마주치게 되는
      identifier의 첫번째 사용에 대해서 경고를 발생합니다. 경고는 identifier를
      쓸모없는 상태로 만듭니다.
    ex)
    // io.h
    #if !defined(RC_INVOKED)

    /* Obsolete functions */
    #pragma obsolete _chmod
    #pragma obsolete _close
    #pragma obsolete _creat
    #pragma obsolete _open
    #pragma obsolete _read
    #pragma obsolete _write

/* restore default packing */
#pragma pack(pop)

    #if defined(__STDC__)
    #pragma warn .nak
    #endif

#endif /* !RC_INVOKED */

//--------------------------------------------------------------------------

13.#pragma option
    . 사용법
      #pragma option options
      #pragma option push options
      #pragma option pop
    . #pragma option은 프로그램 원시 코드 내에 명령라인 옵션을 포함시키고자
      할 때 사용하며 push 또는 pop 옵션과 함께 사용되어질 수 있습니다.
      options는 임의의 명령라인 옵션(단, 아래에 수록된 것은 제외합니다.)이며
      하나의 지시어 내에서 여러개의 option들을 나타낼 수 있습니다.
      예를 들자면 다음과 같습니다.

#pragma option -C
#pragma option -C -A

      toggle option(-a, -K같은)은 comman line에서 on/off될수 있습니다.
      이들 toggle option들은 option 다음에 마침표를 두면 그 명령라인, 구성 파일,
      옵션 메뉴 설정값에 대해 옵션을 리털할 수 있으며 이를 이용하면 정확한
      설정값을 기억하지 않고도(혹은 알 필요가 없거나) 옵션을 임시로 변경했다가
      다시 그것을 디폴트로 복귀시킬 수 있습니다.

      pragma optino에 포함하여 나타날 수 없는 옵션들은 다음과 같습니다.
      -B   -c   -dname
      -Dname=string   -efilename   -E
      -Fx -h   -lfilename
      -lexset   -M   -o
      -P   -Q   -S
      -T   -Uname   -V
      -X   -Y
      다음의 경우에 #pragmas, #indluces, #define과 약간의 #ifs를 사용할 수
      있습니다.
      * #if, #ifdef, #ifndef 또는 #elif지시어 내에서 두 밑줄로 시작하는 매크로명
        (그리고 그에 따른 내장 매크로도 가능합니다.)의 사용 전.
      * 첫번째 실재 token이 발생하기 전(첫번째 C 또는 C++ 선언문)

      특정 명령 라인 옵션은 이들 사건 앞의 #pragma option 내에서만 나타날 수
      있는데 그러한 option들은 다음과 같습니다.
      -Efilename        -f      -i#
      -m*   -npath   -ofilename
      -u   -W   -z

      다른 option들은 어디서나 변경될 수 있는데 다음 option들은 함수 또는 대상
      선언문 사이에서 변경될 경우 컴파일러에만 영향을 미칩니다.
      -1        -h      -r
      -2   -k   -rd
      -a   -N   -v
      -ff -O   -y
      -G   -p   -Z

      다음의 option들은 언제든지 변경될 수 있으며 즉시 영향을 미칠 수 있습니다.
      -A   -gn   -zE
      -b   -jn   -zF
      -C   -K   -zH
      -d   -wxxx
      이들 option들은 그 명령 라인 상태로 재설정하기 위해 점(.)앞에 추가로
      나타날 수 있습니다.

      push 또는 pop을 사용한 #pragma option
      18:41, 21 February 2007 (PST)18:41, 21 February 2007 (PST)18:41, 21 February 2007 (PST)18:41, 21 February 2007 (PST)18:41, 21 February 2007 (PST)18:41, 21 February 2007 (PST)18:41, 21 February 2007 (PST)~~
      또한 콤파일러 지시어들을 쉽게 변경할 수 있도록 push 그리고 pop 아규먼트들
      과 함께 #pragma option 지시어를 사용할 수도 있습니다.

      잠재적으로 많은 컴파일러 옵션과 경고들을 변경하는 파일들을 포함하기 위해
      #pragma option push를 사용할 수 있고, #pragma option pop은 단일 문장으로서
      이전의 상태를 되돌려준다. 예를 들자면 다음과 같다.

      #pragma option push
      #include <theworld.h>
      #pragma option pop
      #include "mystuff.h"

      #pragma option push 지시어는 첫번째로 모든 콤파일러 옵션들과 경고 설정들을
      스택에 push한 후에 다른 옵션들이 존재한다면 이를 처리한다. 다음의 예는
      #pragma option push가 옵션들을 사용하거나 혹은 그렇지 않을수 있음을
      보여줍니다.

#pragma option push -C -A
#pragma option push

      #pragma option pop directive은 스택으로부터 옵션들과 경고들의 마지막 설정
      을 pop함으로서 컴파일러 옵션과 경고들을 변경합니다. 만일 스택이 비어있고
      option pop과 일치하는 option push가 없으며 아무것도 발생하지 않은경우
      경고가 주어집니다. 다음은 빈 스택에대해서 경고를 발생시킵니다.

      #pragma option push
      #pragma option pop
      #pragma option pop      /* 경고가 발생합니다.

권장하지는 않지만 지시어를 사용하여 이 경고를 off시킬 수 있습니다.
#pragma warn -nop.

      만일 pop의 다음에 어떤 옵셥들을 명시할려고 한다면 에러가 발생하게되며
      pragma option pop 다음에는 어떤것도 허락하지 않습니다. 예를 들면, 다음은
      에러를 발생합니다.

      #pragma option pop -C         /* ERROR
      만일 push된 옵션들의 스택이 파일의 시작과 마지막이 동일하지 않다면
      다음과 같은 경고메세지가 발생합니다.

Previous options and warnings not restored.

이 경고메세지를 off시키기 위하여 지시어 #pragma nopushoptwarn를 사용할
수 있습니다.

//--------------------------------------------------------------------------

14. #pragma pack

    변수 정렬을 인위적으로 변경시킨다.(보통은 4바이트로 지정되어 있다.)
    . 사용법
      #pragma pack(n)

         위에서, n의 값으로, 1,2,4,8등이 올수 있으며, 특히 네트웍통신쪽을 개발할때
         구조체의 멤버들 align할때 사용하는 것으로서, 빈번하게 사용됩니다.
        구조체 정렬부분은 중요하지만, 여기서는 그쪽까지 언급하기에는 양이 많아서
         여기까지만 설명함.
      #pragma pack(push, n)

      #pragma pack(pop)
    . #pragma pack 지시어는 콤파일러 옵션 -a와 함께 #pragma option을 사용하는
      것과 동일합니다. n은 콤파일러가 저장된 메모리에 데이터를 정렬하는 방법을
      결정하는 byte의 정렬이다. 보다 자세한 사항은 -a 콤파일러 옵션에 관한
      내용을 참고하십시요. #pragma pack은 또한 #pragma option지시어에 push나
      pop을 사용하는것과 동일한 기능을 제공 하도록 push나 pop 아규먼트와 함께
      사용할 수 있습니다. 아래의 내용은 #pragma pack과 #pragma option을 비교한
      내용입니다.
      ━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━
      #pragma pack              ┃     #pragma option
      ━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━
      #pragma pack(n)           ┃     #pragma option -an
      #pragma pack(push, n)     ┃     #pragma option push -an
      #pragma pack(pop)         ┃     #pragma option pop
      ━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━

예) #pragma pack(push, before_pack, 1)
구조체 정렬을 1 바이트로 만든다. 1 바이트로 맞추기 전의 정렬 기준을 before_pack에 저장한다

#pragma pack(pop, before_pack)
위와 같이 한쌍으로 사용된다. before_pack에 저장된 정렬 기준으로 복원한다.

        다음과 같이 사용할 수도 있다.
         #pragma pack(push, 1)
         #pragma pack(pop)

다음과 같이 복원없이 지정할 수도 있다.
#pragma pack(1)

    예) #pragma pack(pop) 이라...아마 이거랑 쌍이 되는게 있을텐데요
         #pragma pack(push,1) 이라던지요.
         이건 구조체를 1바이트로 바이트 정렬하는 겁니다. 디폴트로는 8바이트로 되어 있을겁니다.
         뭐 구조체 크기가 실제로 계산한 것과 맞지 않는 경우가 있는데..이 바이트 정렬 떄문입니다.
         따라서..반드시 맞아야 할 경우는... 위의 코드를 구조체 아래위로 써야 합니다.
//--------------------------------------------------------------------------

15.#pragma package
    . 사용법
      #pragma package(smart_init)
      #pragma package(smart_init, weak)
    . smart_init 아규먼트
      #pragma package(smart_init)는 패키지된 유닛들이 의존할 순서를 결정하기위해
      초기화 되어집니다.(패키지 소스파일 내에 기본적으로 포함됩니다.)
      일반적으로, 패키지들을 생성하는 .CPP 파일들에 #pragma package를 사용할 수
      있습니다.
      이 프라크마는 유닛을 콤파일하는기위한 초기의 순서에 영향을 미칩니다.
      초기화는 다음의 순서에 의하여 발생합니다.
      1. 만일 unitA가 unitB에 의존한다면 unitB는 반드시 unitA전에 초기화
         되어져야만하는 사용("uses")에 의존합니다.
      2. 링크의 순서(The link order)
      3. unit에서의 우선권의 순서.(Priority order within the unit.)

      보통의 .OBJ 파일들은(unit들로 생성하지 않은), 첫째로 우선권의 순서에 따라
      초기화가 일어나고서 링크가 됩니다. .OBJ 파일들의 링크 순서의 변경은
      글로발 오브젝트가 호출되어져 생성되는 순서에 의해 변경됩니다.

      다음의 예는 보통의 .OBJ 파일들과 unit들의 초기화에 어떤 차이점이 있는가를
      보여줍니다. 세개의 unit 파일들 A,B,C가 #pragma package(smart_init)를
      사용하여 "smart initialized"되고 우선권은 10, 20, 30의 값을 갖는다고
      예를 듭니다. 함수는 우선권의 값과 parent .OBJ에 의하여 이름지어져 a10,
      a20, a30, b10등과 같은 이름을 갖습니다. 세가지는 모두 unit들이며 A는 B와
      C를 사용하며 A,B,C의 순서로 링크되고 초기화의 순서는 다음과 같습니다.
           B10 B20 B30 C10 C20 C30 A10 A20 A30
      위와 같이 되었다면 .OBJ 파일들은 (unit들이 아니다)다음의 순서가 되어질
      것입니다.
           A10 B10 C10 A20 B20 C20 A30 B30 C30
      #pragma package(smart_init)를 사용한 .CPP 파일들은 또한 #pragma package
      (smart_init)를 정의한 .CPP 파일로부터 다른 .OBJ 파일들을 참조하는 #pragma
      link를 필요로 하며 unit에 의해 결정되어져야만 합니다. #pragma link는, 결정
      되지 않은 .OBJ는 라이브러리 등에 의하여 여전히 결정되어질 수 있도록 참조
      할 수 있습니다.
    . weak packages
      #pragma package(smart_init, weak)지시어는 .OBJ 파일이 패키지의 .BPI와
      .BPL 파일들에 정장되는 방법에 영향을 미칩니다. 만일 #pragma package(smart_
      init, weak)가 unit파일 내에 나타난다면 콤파일러는 가능하다면 BPL들로부터
      unit을 생략하고, 다른 에플리케이션이나 패키지에 의해 필요로 할 때면
      비 패키지화된(non-packaged) 로칼 복사본의 unit을 생성합니다. 유닛이 이
      지시어와 함께 콤파일 되었다는 것은 약하게 패키지화 되었음을 이야기 합니다.
      ("weakly packaged")
      #pragma package(smart_init, weak)는 동일한 외부 라이브러리(external librar
      y)들에 의존할수 있는 여러 패키지들 사이에서의 충돌을 제거하는데 사용되어
      집니다. #pragma package(smart_init, weak) 지시어를 가지는 unit 파일들은
      글로발 변수들을 갖지 않아야 합니다.

//--------------------------------------------------------------------------
16.#pragma resource
    . 사용법
      #pragma resource "*.dfm"
    . 이 프라그마는 form unit에 의해 선정되어지는 파일로서 일치되는 .DFM 파일과
      헤더파일을 필요로 합니다. 이러한 모든 파일들은 IDE에 의해 관리되어집니다.
      만일 폼을 위한 다른 변수들을 필요로한다면 pragma resource가 사용되어지고난
      후에 즉시 선언되어져야만 합니다. 선언은 반드시 form이 되어져야만 합니다.
          TFormName *Formname;

//--------------------------------------------------------------------------
17.#pragma startup
    . 사용법
      #pragma startup function-name <priority>
      #pragma exit function-name <priority>
    . #pragma exit의 내용을 참조하십시요.

//--------------------------------------------------------------------------
18.#pragma warn
    . 사용법
      #pragma warn [+:-:.]www
    . warn지시어를 이용하면 특정 명령라인 옵션 -wxxx를 우선할 수 있습니다.
      #pragma warn -aus 스위치를 사용하면 함수 단위로 취급됩니다. 개별적인
      변수들을 위해서 함수 내부에서 경고를 off시킬수는 없습니다. 함수 전체를
      off시키거나 혹은 그렇지 않거나 둘중 하나입니다.
    ex)
    #pragma warn +xxx
    #pragma warn -yyy
    #pragma warn .zzz

위의 예에서는 xxx경고문은 on되고 yyy경고문은 off되며 zzz경고문은 파일의
컴파일이 시작할 때 갖고 있던 값으로 재저장됩니다.

//----- End of Document ----------------------------------------------------
19. #pragma once

1. 한번 컴파일 되면 더 이상 컴파일 하지 않는다는 뜻입니다.
여러개의 cpp파일이 있을때, 하나의 cpp화일이 수정되면, 그 화일만 컴파일하고
나머지는 하지말아란 뜻이죠. ( 여러 번 인클루드 되는 것을 컴파일러 차원에서 막아줌 )

2. #ifndef ~ #endif 와 같은 역할을 한다.

3. 매크로들의 중복 정의를 막고, 전역변수에 static 키워드를 써줄 필요가 없어짐.

4. VC++ 에서는 되고, 다른 컴파일러는 안될 수도 있음.

5. 분할 컴파일시

이것을 사용하면 빌드시 컴파일러에 의해 해당 파일을 단 한번만 열게 된다... 그러므로 컴파일 타임을 줄일 수 있고 모듈에서 가장 먼저 나온 #include문에서 해당 파일을 열게 되므로 재정의에 의한 오류를 방지할 수 있다...

예제)

// exam.h file

#ifndef __EXAM__

#define __EXAM__

...

#endif

// exam.h file

#pragma once

...

//--------------------------------------------------------------------------

20. #pragma data_seg

dll에서 데이터 공유하고자 할 때 쓰임

예) 실행파일에는 코드영역과 데이터영역이 구분되어 있다는 것은 아시지요.
┌───────┐
│                     │
│                     │
│   데이터영역   │
│                     │
│                     │
├───────┤
│                     │
│                     │
│     코드 영역   │
│                     │
│                     │
└───────┘
   이런 식의 그림은 아마 어디선가 많이 보셨을겁니다.(그림이 깨지네요.편집할 땐 제대로 보였는데...)
   이런 영역을 section이라고 하지요. 위의 설명에 나오는 section이라는 용어가 이것입니다.
   실제로 데이터 영역과 코드 영역외에도 exe나 dll에는 여러 section을 포함할 수 있습니다.
   이건 dumpbin이라는 툴로 살펴볼 수 있습니다.
   제 컴(Windows XP)에서 dumpbin c:\windows\notepadd.exe 를 해 보았더니

   2000 .data
   2000 .rsrc
   7000 .text

이렇게 나오는 군요.

   여기서 .data에는 초기화된 데이터가 .rsrc에는 리소스들이, .text에 코드가 들어갑니다.
   이러한 .data, .rsrc, .text 등은 일반적으로 정해져 있는 것들입니다.
   위 MSDN의 설명에 있는 section-name이라는 것이 바로 .data, .rsrc, .text 등을 뜻하는 겁니다.
   즉, #pragma code_seg( .data ) 처럼 사용한다는 거지요.
   그리고 Specifies a code section where functions are to be allocated.라는 설명은 Specifies a section where functions or data or etc. are to be allocated. 이렇게 이해하면 더 나을 듯 하네요.

그런데 이런 정해진 이름말고도 사용자가 새로운 영역을 정할 수 있습니다.

   #pragma data_seg("Shared")
   DWORD g_dwThreadIdPMRestore = 0;
   HWND g_hwnd = NULL;
   #pragma data_seg()

이런 식으로 하면 g_dwThreadIdPMRestored와 g_hwnd가 디폴트 데이터 섹션인 .data에 배치되지 않고, Shared라는 이름으로 만들어진 섹션에 배치되는 것입니다.

//--------------------------------------------------------------------------

21. #pragma warning

컴파일시에 어떤 조건(#if, #ifndef)에의해 개발자에게 어떤것을 알려주고 싶을 경우 사용.

예) #pragma warning(disable:xxxx)
지정된 xxxx번대의 경고 메세지를 디스플레이하는 것을 막는다. (xxxx는 번호)

warning( disable : 4705 )

: 특정 warnning 을 체크하지 않음, 이럴 경우 4705번 warnning은 나타나지 않는다

#pragma warning(default:xxxx)
지정된 xxxx번의 경고 메세지의 설정을 원래의 프로젝트 설정으로 복원한다

//--------------------------------------------------------------------------

22. #pragma code_seg

MSDN에 있는 내용
#pragma code_seg( ["section-name"[,"section-class"] ] )

Specifies a code section where functions are to be allocated. The code_seg pragma specifies the default section for functions. You can, optionally, specify the class as well as the section name. Using #pragma code_seg without a section-name string resets allocation to whatever it was when compilation began.

//--------------------------------------------------------------------------

23. #pragma deprecated

    C#의 Obsolete attribute와 비슷한 의미입니다.
    즉, 경고가 발생한 클래스 혹은 메서드 등이 이후에는 지원되지 않음을 나타내는 의미입니다.
    그러므로 당장은 문제가 없습니다.

컴파일러 specific 한..그런 옵션 지시자라고 보시면 됩니다.

//--------------------------------------------------------------------------

#pragma는 표준 C/C++ 문법인데 각 compiler 마다 다른 명령을 제공한다... 고로 Linux나 Unix의 cc에서는 작동하지 않을 수도 있다는 것! (Visual C++에선 언제나 call...)

pragma 는 #로 시작하는 전처리구문 지시자 중 컴파일러에 종속적인 명령으로, 컴파일러에 특정한 옵션 명령을 내리기 위해 사용한다.

이것은 컴파일러에 종속적이기 때문에 컴파일러를 변경했을 경우 실행을 보장하지 못한다.

pragma 의 의미를 action 으로 많이들 알고 계시는데, 인터넷에서 제가 알아본바로는, 사전적인 의미는 "만능" 입니다. 어원설명 원문은, 아래를 참고하세요.

A pragma (from the Greek word meaning action) is used to
direct the actions of the compiler in particular ways, but
has no effect on the semantics of a program (in general).

Pragmas are used to control listing, to define an object
configuration (for example, the size of memory), to control
features of the code generated (for example, the degree of
optimization or the level of diagnostics), and so on.

Such directives are not likely to be related to the rest of
the language in an obvious way. Hence the form taken should
not intrude upon the language, but it should be uniform.

Thus, the general form of pragmas is defined by the language.
They start with the reserved word pragma followed by a pragma
identifier, optionally followed by a list of arguments enclosed
by parentheses, and terminated by a semicolon.

The overall syntax of the pragma identifier and arguments is
similar to that of a procedure call. Pragmas are allowed at
places where a declaration or a statement is allowed; also at
places where other constructs that play the role of declarations
(for example clauses) are allowed.

pragma 는 컴파일에게 그 뒤에오는 내용에 따라 어떤일을 하라는 전처리명령입니다.

C++는 컴파일하고 나면 함수의 이름이 바뀌게 되는데 이것을 name mangling이라고 합니다.

그래서 만일 dll로 작성한 함수를 불러 사용하게 되면 같은 이름을 찾을 수 없다는 오류가 나게 됩니다.

만일 dll에서 printString라는 함수를 만들었다고 가정을 합니다. 그러면 컴파일하고 난 후의 함수의 이름은 printString@@YAXXZ와 같은 형태로 만들어 집니다.
그런데 이 함수를 불러 사용하는 곳은 printString이라는 것만 알지 위의 것과 같은 알지 못합니다. 그래서 #pragma라는 키워드를 사용해서 name mangling을 방지하게 되는 것입니다.
이 mangling된 이름을 찾기 위해서는 VC++ Tool에 보면 depends를 실행하고 만들dll을 drag&drop하면 이것을 찾을 수 있습니다.

pragma comment(linker, "/export:printString=?printString@@YAXXZ")와 같이사용하면됩니다.

즉 #pragma는 원래의 함수 이름을 c++의 암호명에 대한 별칭으로 추가하도록 지시하며 링커에게 /export옵션을 전달해 주는것입니다.
그리고 dll에서는 원래의 함수를 export(수출??말이 좀 이상하지만 대부분 이렇게 많이 쓰니까..^^)해야 하고 이 함수를 호출하는 쪽에서는 import(수입) 옵션을 써 주어야만 함수를 제대로 호출할 수 있습니다.

pragma 앞에 #이 있는 걸 보면 아시겠지만 pragma는 precompiler입니다.

compile할 때 platform이 틀려지거나 cpu가 틀려지거나 할 때 compile option을 주게 됩니다.

vc++을 써보셨으면 아실텐데, project settings( ALT+F7 )에서 c/c++ tab에 보면 project options이 있습니다. link tab에도 project options가 있죠.

pragma가 바로 그런 역할을 하는 precompiler입니다.

vc++이야 ide니까 project settings라는 편한 환경을 지원하지만 만약 code호환성을 생각한다면 pragma를 쓰는 게 좋죠.

< api나 mfc의 구분과 관계없이 해당 컴파일러에서 사용하는 명령 >

#pragma warn- // warning 디스어블

pragma warn+ // warning 인에이블
pragma opt- // 최적화 안 함
pragma opt+ // 최적화 함
pragma savereg- // 레지스터 저장 안 함
pragma savereg+ // 레지스터 저장 함
pragma library mylib.lib // 링크 라이브러리 지정

※ MSDN / "Programming Applications for Microsoft Windows"(Jeffrey Richer 저) 참조

저작자표시 비영리 변경금지

'Programming > C++' 카테고리의 다른 글

[펌] How to: Debug from a DLL Project (0)	2016.03.26
[펌] C++ DebugView로 디버그 메시지 보기 (0)	2015.05.13
How to: Parse Strings Using the Split Method (C++/CLI) (0)	2015.04.22

Posted by 세모아

이전 1 다음

세상의 모든 아침

'2016/03'에 해당되는 글 9건

p12 인증서를 하드디스크에 넣기

'생활팁.잡동사니' 카테고리의 다른 글

rtsp url

'Programming' 카테고리의 다른 글

[펌] FFMPEG: Can not free AVPacket when decode H264 stream?

'Programming > C++' 카테고리의 다른 글

av_free_packet 예제들

'Programming > C++' 카테고리의 다른 글

[펌] ffmpeg - rtmp sample 테스트 (rtsp도 포함)

ffmpeg - rtmp sample 테스트

'Programming > C++' 카테고리의 다른 글

[펌] How to: Debug from a DLL Project

How to: Debug from a DLL Project

To specify the calling application in a C++ project

To specify the calling application in a C# or Visual Basic project

To start debugging from the DLL project

'Programming > C++' 카테고리의 다른 글

[펌] c++ dll (/clr) 을 c#에서 dllimport 하고 디버그(debug) 하기

c++ dll (/clr) 을 c#에서 dllimport 하고 디버그(debug) 하기

'Programming > C#' 카테고리의 다른 글

[펌] 효과적인 C# 메모리 관리 기법

'Programming > C#' 카테고리의 다른 글

[펌] pragma에 관한 사용법

'Programming > C++' 카테고리의 다른 글

카테고리

태그목록

최근에 올라온 글

최근에 달린 댓글

최근에 받은 트랙백

글 보관함

달력

링크

티스토리툴바