Microsoft MVP성태의 닷넷 이야기
개발 환경 구성: 440. C#, C++ - double의 Infinity, NaN 표현 방식 [링크 복사], [링크+제목 복사],
조회: 18762
글쓴 사람
정성태 (techsharer at outlook.com)
홈페이지
첨부 파일
(연관된 글이 1개 있습니다.)
(시리즈 글이 8개 있습니다.)
.NET Framework: 539. C# - 부동 소수 계산 왜 이렇게 나오죠? (1)
; https://www.sysnet.pe.kr/2/0/10872

.NET Framework: 540. C# - 부동 소수 계산 왜 이렇게 나오죠? (2)
; https://www.sysnet.pe.kr/2/0/10873

.NET Framework: 608. double 값을 구할 때는 반드시 피연산자를 double로 형변환!
; https://www.sysnet.pe.kr/2/0/11055

개발 환경 구성: 440. C#, C++ - double의 Infinity, NaN 표현 방식
; https://www.sysnet.pe.kr/2/0/11896

기타: 85. 단정도/배정도 부동 소수점의 정밀도(Precision)에 따른 형변환 손실
; https://www.sysnet.pe.kr/2/0/13212

닷넷: 2257. C# - float (단정도 실수) 저장소의 비트 구조
; https://www.sysnet.pe.kr/2/0/13617

닷넷: 2258. C# - double (배정도 실수) 저장소의 비트 구조
; https://www.sysnet.pe.kr/2/0/13618

닷넷: 2259. C# - decimal 저장소의 비트 구조
; https://www.sysnet.pe.kr/2/0/13619




C#, C++ - double의 Infinity, NaN 표현 방식

Raymond Chen의 글에 따르면,

What does -1.#IND mean?: A survey of how the Visual C runtime library prints special floating point values
; https://blogs.msdn.microsoft.com/oldnewthing/20130221-00/?p=5183

다음과 같은 특별한 double 값들이 있습니다.

1#INF   Positive infinity 
-1#INF  Negative infinity 

1#SNAN  Positive signaling NaN 
-1#SNAN Negative signaling NaN 

1#QNAN  Positive quiet NaN 
-1#QNAN Negative quiet NaN 

1#IND   Positive indefinite NaN 
-1#IND  Negative indefinite NaN 

우선, 가장 쉬운 infinity에 대해 볼까요? ^^ 대표적인 재현 코드로는 0이 아닌 수를 0으로 나누는 것인데, 말 그대로 무한대의 값을 표현하는 것으로 부호에 따라 양의 무한대, 음의 무한대를 표현합니다. C#으로는 다음과 같이 표현할 수 있습니다.

using System;
using System.Runtime.CompilerServices;

class Program
{
    static unsafe void Main(string[] args)
    {
        WriteValue(double.PositiveInfinity, nameof(double.PositiveInfinity));
        WriteValue(double.NegativeInfinity, nameof(double.NegativeInfinity));
    }

    private static unsafe void WriteValue(double value, string title)
    {
        byte* pBytes = (byte*)&value;
        ulong* pLong = (ulong*)pBytes;
        Console.WriteLine(title + ": 0x" + (*pLong).ToString("x"));
    }
}

/* 출력 결과
PositiveInfinity: 0x7ff0000000000000
NegativeInfinity: 0xfff0000000000000
*/

이것을 double의 메모리 표현과 엮어 볼까요? ^^

/* C++ 코드 */
typedef union tagDoubleExt 
{
    struct
    {
        unsigned int mantisaPart2 : 32;
        unsigned int mantisaPart1 : 20;
        unsigned int exponent : 11;
        unsigned int sign : 1;
    } d;

    double value;

} DoubleExt;

Infinity의 경우에는 위의 코드에서 지수부 11비트가 모두 1 (0x7ff)이고 가수부 52비트가 모두 0인 값을 의미합니다.

exponent = 0x7ff
mantisa == 0

단지, sign == 0이면 PositiveInfinity, 1이면 NegativeInfinity입니다.




다음으로 NaN의 경우에는 제법 복잡합니다. 문서에 의하면, signaling, quiet, indefinite 유형으로 나뉘는데 C#의 경우에는 단일하게 무조건 double.NaN의 출력으로 처리하므로 다른 점을 찾을 수 없습니다. 대신 C/C++ 코드로는 확인할 수 있습니다.

C/C++의 경우에는 double (인 경우 8 바이트) 내용이 초기화되지 않은 메모리인 경우 말 그대로 적절한 IEEE 부동 소수점 포맷에 맞지 않는 값일 때 "Not a Number"라는 의미로 NaN 값을 가지게 됩니다. 물론 약간의 운이 따라야만 초기화되지 않은 double 값이 NaN 값을 가지게 되는데요, IEEE 표준에 의하면 NaN은 지수부 11비트가 전부 1(0x7ff)이면서 가수부는 최소 1비트 이상이 설정된 경우라고 합니다. 따라서 이 값은 Infinity와는 달리 가수부 경우의 수만큼 NaN 바이트 표현이 존재합니다. 가령, 아래의 경우 모두 NaN에 해당합니다.

#include <math.h>
#include <stdio.h>
#include <string>
#include <numeric>

using namespace std;

//double 형식의 메모리를 확인하기 위한 공용체 정의
typedef union tagDoubleExt 
{
    struct
    {
        unsigned int mantisaPart2 : 32;
        unsigned int mantisaPart1 : 20;
        unsigned int exponent : 11;
        unsigned int sign : 1;
    } d;

    unsigned char buf[8];
    double value;

} DoubleExt;

void print(string title, DoubleExt t)
{
    printf("[%s] %lf is \t", title.c_str(), t.value);

    // little endian
    for (int i = 7; i >= 0; i--)
    {
        printf("%02X ", t.buf[i]);
    }

    printf("\n");
}

int main(void)
{
    DoubleExt dblValue;

    {
        memset(&dblValue, 0, sizeof(dblValue));
        dblValue.d.exponent = 0x7ff;
        dblValue.d.mantisaPart1 = 101;
        print("sign = 0, exp = 0x7ff, mantisaPart1 = 101", dblValue);

        dblValue.d.sign = 1;
        print("sign = 1, exp = 0x7ff, mantisaPart1 = 101", dblValue);
    }

    {
        memset(&dblValue, 0, sizeof(dblValue));
        dblValue.d.exponent = 0x7ff;
        dblValue.d.mantisaPart2 = 1;
        print("sign = 0, exp = 0x7ff, mantisaPart2 = 1", dblValue);

        dblValue.d.sign = 1;
        print("sign = 1, exp = 0x7ff, mantisaPart2 = 1", dblValue);
    }

    return 0;
}

/* 출력 결과
[sign = 0, exp = 0x7ff, mantisaPart1 = 101] nan(snan) is        7F F0 00 65 00 00 00 00
[sign = 1, exp = 0x7ff, mantisaPart1 = 101] -nan(snan) is       FF F0 00 65 00 00 00 00
[sign = 0, exp = 0x7ff, mantisaPart2 = 1] nan(snan) is  7F F0 00 00 00 00 00 01
[sign = 1, exp = 0x7ff, mantisaPart2 = 1] -nan(snan) is         FF F0 00 00 00 00 00 01
*/

보는 바와 같이 출력값에서 "(snan)"이 나오는데 바로 이 경우가 부호에 따라 1#SNAN, -1#SNAN으로 표현되는 값입니다.

1#SNAN  Positive signaling NaN 
-1#SNAN Negative signaling NaN 

그다음 quiet NaN은 mantisa 가수부의 최상위 1비트가 1이면서 나머지 가수부가 최소 1 이상의 값인 경우에 해당합니다. 즉, 다음과 같이 double을 구성하면 재현할 수 있습니다.

/*
How to get the sign, mantissaand exponent of a floating point number
; https://stackoverflow.com/questions/15685181/how-to-get-the-sign-mantissa-and-exponent-of-a-floating-point-number
*/
typedef union tagDoubleExt 
{
    struct
    {
        unsigned int mantisaPart2 : 32;
        unsigned int mantisaPart1 : 19;
        unsigned int quiet_nan : 1;
        unsigned int exponent : 11;
        unsigned int sign : 1;
    } d;

    unsigned char buf[8];
    double value;

} DoubleExt;

{
    memset(&dblValue, 0, sizeof(dblValue));
    dblValue.d.exponent = 0x7ff;
    dblValue.d.quiet_nan = 1;
    dblValue.d.mantisaPart1 = 101;
    print("sign = 0, exp = 0x7ff, quiet=1, mantisaPart1 = 101", dblValue);

    dblValue.d.sign = 1;
    print("sign = 1, exp = 0x7ff, quiet=1, mantisaPart1 = 101", dblValue);
}

{
    memset(&dblValue, 0, sizeof(dblValue));
    dblValue.d.exponent = 0x7ff;
    dblValue.d.quiet_nan = 1;
    dblValue.d.mantisaPart2 = 1;
    print("sign = 0, exp = 0x7ff, quiet=1, mantisaPart2 = 1", dblValue);

    dblValue.d.sign = 1;
    print("sign = 1, exp = 0x7ff, quiet=1, mantisaPart2 = 1", dblValue);
}

/* 출력 결과
[sign = 0, exp = 0x7ff, quiet=1, mantisaPart1 = 101] nan is     7F F8 00 65 00 00 00 00
[sign = 1, exp = 0x7ff, quiet=1, mantisaPart1 = 101] -nan is    FF F8 00 65 00 00 00 00
[sign = 0, exp = 0x7ff, quiet=1, mantisaPart2 = 1] nan is       7F F8 00 00 00 00 00 01
[sign = 1, exp = 0x7ff, quiet=1, mantisaPart2 = 1] -nan is      FF F8 00 00 00 00 00 01
*/

그런데, 이번에는 보는 바와 같이 "quiet"를 식별하는 출력 없이 그냥 "nan"으로만 찍힙니다. 이제 남은 것은, "indefinite NaN"인데요.

1#IND   Positive indefinite NaN 
-1#IND  Negative indefinite NaN 

이것은 위의 quiet nan에서 quiet 비트를 제외한 다른 가수부의 값을 0으로 만들면 됩니다.

{
    memset(&dblValue, 0, sizeof(dblValue));
    dblValue.d.exponent = 0x7ff;
    dblValue.d.quiet_nan = 1;
    print("sign = 0, exp = 0x7ff, quiet=1, mantisa = 0", dblValue);

    dblValue.d.sign = 1;
    print("sign = 1, exp = 0x7ff, quiet=1, mantisa = 0", dblValue);
}

/* 출력 결과
[sign = 0, exp = 0x7ff, quiet=1, mantisa = 0] nan is    7F F8 00 00 00 00 00 00
[sign = 1, exp = 0x7ff, quiet=1, mantisa = 0] -nan(ind) is      FF F8 00 00 00 00 00 00
*/

단지, "-nan(ind)"의 경우에는 구분이 되는 반면 "nan(ind)"인 듯한 값은 C/C++도 그냥 "nan"으로 출력합니다. (혹시 "Positive indefinite NaN"에 관한 정확한 정보를 아시는 분은 덧글 부탁드립니다. ^^)

여기까지 해서 각각의 nan/inf에 대해 정리해 보면 다음과 같습니다.

1#INF   Positive infinity 
    exponent = 0x7ff
    mantisa == 0
    sign = 0
-1#INF  Negative infinity 
    exponent = 0x7ff
    mantisa == 0
    sign = 1

1#SNAN  Positive signaling NaN 
    exponent = 0x7ff
    mantisa == (1이 아닌 값)
    sign = 0
-1#SNAN Negative signaling NaN 
    exponent = 0x7ff
    mantisa == (1이 아닌 값)
    sign = 1

1#QNAN  Positive quiet NaN 
    exponent = 0x7ff
    mantisa == 최상위 비트가 1, 나머지 가수부에는 1이 아닌 값
    sign = 0
-1#QNAN Negative quiet NaN 
    exponent = 0x7ff
    mantisa == 최상위 비트가 1, 나머지 가수부에는 1이 아닌 값
    sign = 1

1#IND   Positive indefinite NaN 
    (출력은 안되지만, 아마도)
    exponent = 0x7ff
    mantisa == 최상위 비트만 1
    sign = 0
-1#IND  Negative indefinite NaN 
    exponent = 0x7ff
    mantisa == 최상위 비트만 1
    sign = 1




알아본 김에, C++의 NaN 관련 값/함수들을 알아볼까요? ^^

우선 NAN(매크로 상수)는,

dblValue.value = NAN;
print("NAN", dblValue); // == -1#IND

dblValue.value = -NAN;
print("-NAN\t", dblValue); // == 1#IND

/* 출력 결과
[NAN] -nan(ind) is      FF F8 00 00 00 00 00 00
[-NAN   ] nan is        7F F8 00 00 00 00 00 00
*/

보는 바와 같이 NAN 값이 "-1#IND"에 해당하는 비트 값을 가집니다. 그다음, std::numeric_limits::signaling_NaN()은,

dblValue.value = std::numeric_limits<double>::signaling_NaN();
print("signaling_NaN", dblValue); // == 1#QNAN

dblValue.value = -std::numeric_limits<double>::signaling_NaN();
print("-signaling_NaN", dblValue); // == -1#QNAN

/* 출력 결과
[signaling_NaN] nan is  7F F8 00 00 00 00 00 01
[-signaling_NaN] -nan is        FF F8 00 00 00 00 00 01
*/

signaling이라는 단어가 무색하게 "quiet" 비트가 1로 설정된 1#QNAN, -1#QNAN에 해당하는 비트 값을 가집니다. 반면 std::numeric_limits::quiet_NaN()은,

dblValue.value = std::numeric_limits<double>::quiet_NaN();
print("quiet_NaN", dblValue); // == -NAN == 1#IND

dblValue.value = -std::numeric_limits<double>::quiet_NaN();
print("quiet_NaN", dblValue); // == NAN == -1#IND

/* 출력 결과
[quiet_NaN] nan is      7F F8 00 00 00 00 00 00
[quiet_NaN] -nan(ind) is        FF F8 00 00 00 00 00 00
*/

(어쨌든 "quiet" 비트가 1이지만) 1#IND, -1#IND의 값을 가집니다. 마지막으로 nan("...") 함수는,

dblValue.value = nan(nullptr);
print("nan(nullptr)", dblValue);

dblValue.value = nan("");
print("nan(empty)", dblValue);

dblValue.value = nan("test");
print("nan(test)", dblValue);

/* 출력 결과
[nan(nullptr)] nan is   7F F8 00 00 00 00 00 00
[nan(empty)] nan is     7F F8 00 00 00 00 00 00
[nan(test)] nan is      7F F8 00 00 00 00 00 00
*/

"1#IND"에 해당하는 값을 반환합니다. 따라서 위의 값/함수들로는 C++에서 "nan(snan)"으로 출력되는 nan 값을 가질 수는 없습니다.




아래의 문서에 보면,

std::numeric_limits::signaling_NaN
; https://en.cppreference.com/w/cpp/types/numeric_limits/signaling_NaN

signaling_NaN 값을 다른 값과 연산하면 "quiet NaN"이 결괏값으로 나온다고 합니다.

#include <iostream>
#include <limits>
#include <cfenv>
#pragma STDC_FENV_ACCESS on

void show_fe_exceptions()
{
    int n = std::fetestexcept(FE_ALL_EXCEPT);
    if(n & FE_INVALID) std::cout << "FE_INVALID is raised\n";
    else if(n == 0)    std::cout << "no exceptions are raised\n";
    std::feclearexcept(FE_ALL_EXCEPT);
}

int main()
{
    double snan = std::numeric_limits<double>::signaling_NaN();
    std::cout << "After sNaN was obtained ";
    show_fe_exceptions();
    double qnan = snan * 2.0;
    std::cout << "After sNaN was multiplied by 2 ";
    show_fe_exceptions();
    double qnan2 = qnan * 2.0;
    std::cout << "After the quieted NaN was multiplied by 2 ";
    show_fe_exceptions();
    std::cout << "The result is " << qnan2 << '\n';
}

/* 출력 결과
After sNaN was obtained no exceptions are raised
After sNaN was multiplied by 2 FE_INVALID is raised
After the quieted NaN was multiplied by 2 no exceptions are raised
The result is nan
*/

위의 소스 코드를 Visual C++로 옮기려면 "#pragma STDC_FENV_ACCESS on" 대신 "#pragma fenv_access(on)"으로 바꿔야 합니다. (이 설정을 하면 부동 소수점 최적화를 하지 않습니다.)

그런데 실제로 snan과 qnan, qnan2의 값이 다를까요? 이것은 환경마다 다른 것 같습니다. 왜냐하면 Visual C++의 경우 다음과 같이 출력하기 때문입니다.

#pragma fenv_access(on)

#include <iostream>
#include <limits>
#include <cfenv>

void show_fe_exceptions()
{
    int n = std::fetestexcept(FE_ALL_EXCEPT);
    if (n & FE_INVALID) std::cout << "FE_INVALID is raised\n";
    else if (n & _EM_ZERODIVIDE) std::cout << "_EM_ZERODIVIDE is raised\n";
    else if (n == 0)    std::cout << "no exceptions are raised\n";
    std::feclearexcept(FE_ALL_EXCEPT);
}

int test_nan()
{
    std::cout << endl;

    DoubleExt dblValue;

    double snan = std::numeric_limits<double>::signaling_NaN();
    dblValue.value = snan;
    print("snan", dblValue);
    std::cout << "1) After sNaN was obtained ";
    show_fe_exceptions();
    std::cout << endl;

    double qnan = snan * 2.0;
    dblValue.value = qnan;
    print("qnan", dblValue);
    std::cout << "2) After sNaN was multiplied by 2 ";
    show_fe_exceptions();
    std::cout << endl;

    double qnan2 = qnan * 2.0;
    dblValue.value = qnan2;
    print("qnan2", dblValue);
    std::cout << "3) After the quieted NaN was multiplied by 2 ";
    show_fe_exceptions();

    return 0;
}

/*
[snan] nan is   7F F8 00 00 00 00 00 01
1) After sNaN was obtained FE_INVALID is raised

[qnan] nan is   7F F8 00 00 00 00 00 01
2) After sNaN was multiplied by 2 no exceptions are raised

[qnan2] nan is  7F F8 00 00 00 00 00 01
3) After the quieted NaN was multiplied by 2 no exceptions are raised
*/

보는 바와 같이 모든 변수의 값에 변함이 없습니다. 단지 결과적으로 봤을 때 signaling, quiet라는 의미에서 이해를 시도해 볼 수 있습니다. 즉, 처음 signaling_NaN을 생성하는 경우 부동 소수점 오류가 발생해 FE_INVALID 값이 설정되는 것입니다. 이후 해당 nan 값에 대해 연산을 시도하는 경우 quiet nan 처리가 된다는 의미에서 부동 소수점 연산에 예외가 발생하지 않는 것입니다.




휴~~~ 어렵군요. ^^; 일단, 정리는 해놨으니 이론적으로 출중하신 분이 이 글을 우연히 읽으신다면 더 좋은 덧글이 달릴 것으로 기대합니다. ^^ 참고로, C#의 경우 아래와 같이 확인을 할 수 있고,

static unsafe void Main(string[] args)
{
    {
        DoubleExp t = new DoubleExp { Value = double.PositiveInfinity };
        WriteValue(double.PositiveInfinity, "1#INF: " + nameof(double.PositiveInfinity));
    }
    {
        DoubleExp t = new DoubleExp { Value = double.NegativeInfinity };
        WriteValue(double.NegativeInfinity, "-1#INF: " + nameof(double.NegativeInfinity));
    }

    Console.WriteLine();

    {
        DoubleExp nanType1 = new DoubleExp();
        nanType1.SetBits(false, 0x7ff, false, 101);

        WriteValue(nanType1.Value, "1#SNAN: false, 0x7ff, false, 101");
    }
    {
        DoubleExp nanType2 = new DoubleExp();
        nanType2.SetBits(true, 0x7ff, false, 101);

        WriteValue(nanType2.Value, "-1#SNAN: true, 0x7ff, false, 101");
    }

    Console.WriteLine();

    {
        DoubleExp nanType1 = new DoubleExp();
        nanType1.SetBits(false, 0x7ff, true, 101);

        WriteValue(nanType1.Value, "1#QNAN: false, 0x7ff, true, 101");
    }
    {
        DoubleExp nanType2 = new DoubleExp();
        nanType2.SetBits(true, 0x7ff, true, 101);

        WriteValue(nanType2.Value, "-1#QNAN: true, 0x7ff, true, 101");
    }

    Console.WriteLine();

    {
        DoubleExp nanType1 = new DoubleExp();
        nanType1.SetBits(false, 0x7ff, true, 0);

        WriteValue(nanType1.Value, "1#IND: false, 0x7ff, true, 0");
    }
    {
        DoubleExp nanType2 = new DoubleExp();
        nanType2.SetBits(true, 0x7ff, true, 0);

        WriteValue(nanType2.Value, "-1#IND: true, 0x7ff, true, 0");
    }

    Console.WriteLine();

    WriteValue(double.NaN, nameof(double.NaN));
}

출력 결과를 놓고 보면,

1#INF: PositiveInfinity(∞): 0x7ff0000000000000
-1#INF: NegativeInfinity(-∞): 0xfff0000000000000

1#SNAN: false, 0x7ff, false, 101(NaN): 0x7ff0000000000065
-1#SNAN: true, 0x7ff, false, 101(NaN): 0xfff0000000000065

1#QNAN: false, 0x7ff, true, 101(NaN): 0x7ff8000000000065
-1#QNAN: true, 0x7ff, true, 101(NaN): 0xfff8000000000065

1#IND: false, 0x7ff, true, 0(NaN): 0x7ff8000000000000
-1#IND: true, 0x7ff, true, 0(NaN): 0xfff8000000000000

NaN(NaN): 0xfff8000000000000

INF를 제외하고는 모든 NAN이 아무런 구별 없이 "NAN"으로 출력되는 것을 볼 수 있습니다. 또한 "double.NaN" 상수는 메모리 표현상으로 보면 "-1#IND" 값과 동일합니다. 즉, C++의 NAN 매크로 상숫값과 같습니다.

(첨부 파일은 이 글의 소스 코드를 포함합니다.)

[https://twitter.com/PR0GRAMMERHUM0R/status/1699530441399636325]
Nan_ne_Nan.jpg




[이 글에 대해서 여러분들과 의견을 공유하고 싶습니다. 틀리거나 미흡한 부분 또는 의문 사항이 있으시면 언제든 댓글 남겨주십시오.]

[연관 글]






[최초 등록일: ]
[최종 수정일: 9/7/2023]

Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.
by SeongTae Jeong, mailto:techsharer at outlook.com

비밀번호

댓글 작성자
 




... 76  77  [78]  79  80  81  82  83  84  85  86  87  88  89  90  ...
NoWriterDateCnt.TitleFile(s)
11860정성태4/5/201918665오류 유형: 527. Visual C++ 컴파일 오류 - error C2220: warning treated as error - no 'object' file generated
11859정성태4/4/201915957디버깅 기술: 125. WinDbg로 EXE의 EntryPoint에서 BP 거는 방법
11858정성태3/27/201916721VC++: 129. EXE를 LoadLibrary로 로딩해 PE 헤더에 있는 EntryPoint를 직접 호출하는 방법파일 다운로드1
11857정성태3/26/201915295VC++: 128. strncpy 사용 시 주의 사항(Linux / Windows)
11856정성태3/25/201915186VS.NET IDE: 134. 마이크로소프트의 CoreCLR 프로파일러 리눅스 예제를 Visual Studio F5 원격 디버깅하는 방법 [1]파일 다운로드1
11855정성태3/25/201917435개발 환경 구성: 436. 페이스북 HTTPS 인증을 localhost에서 테스트하는 방법
11854정성태3/25/201913043VS.NET IDE: 133. IIS Express로 호스팅하는 사이트를 https로 접근하는 방법
11853정성태3/24/201915538개발 환경 구성: 435. 존재하지 않는 IP 주소에 대한 Dns.GetHostByAddress/gethostbyaddr/GetNameInfoW 실행이 느리다면? - 두 번째 이야기 [1]
11852정성태3/20/201915707개발 환경 구성: 434. 존재하지 않는 IP 주소에 대한 Dns.GetHostByAddress/gethostbyaddr/GetNameInfoW 실행이 느리다면?파일 다운로드1
11851정성태3/19/201919149Linux: 8. C# - 리눅스 환경에서 DllImport 대신 라이브러리 동적 로드 처리 [2]
11850정성태3/18/201917327.NET Framework: 813. C# async 메서드에서 out/ref/in 유형의 인자를 사용하지 못하는 이유
11849정성태3/18/201917135.NET Framework: 812. pscp.exe 기능을 C#으로 제어하는 방법파일 다운로드1
11848정성태3/17/201913997스크립트: 14. 윈도우 CMD - 파일이 변경된 경우 파일명을 변경해 복사하고 싶다면?
11847정성태3/17/201918356Linux: 7. 리눅스 C/C++ - 공유 라이브러리 동적 로딩 후 export 함수 사용 방법파일 다운로드1
11846정성태3/15/201916807Linux: 6. getenv, setenv가 언어/운영체제마다 호환이 안 되는 문제
11845정성태3/15/201917460Linux: 5. Linux 응용 프로그램의 (C++) so 의존성 줄이기(ReleaseMinDependency) [3]
11844정성태3/14/201918508개발 환경 구성: 434. Visual Studio 2019 - 리눅스 프로젝트를 이용한 공유/실행(so/out) 프로그램 개발 환경 설정 [1]파일 다운로드1
11843정성태3/14/201913705기타: 75. MSDN 웹 사이트를 기본으로 영문 페이지로 열고 싶다면?
11842정성태3/13/201913204개발 환경 구성: 433. 마이크로소프트의 CoreCLR 프로파일러 예제를 Visual Studio CMake로 빌드하는 방법 [1]파일 다운로드1
11841정성태3/13/201913311VS.NET IDE: 132. Visual Studio 2019 - CMake의 컴파일러를 기본 g++에서 clang++로 변경
11840정성태3/13/201914141오류 유형: 526. 윈도우 10 Ubuntu App 환경에서는 USB 외장 하드 접근 불가
11839정성태3/12/201917112디버깅 기술: 124. .NET Core 웹 앱을 호스팅하는 Azure App Services의 프로세스 메모리 덤프 및 windbg 분석 개요 [3]
11838정성태3/7/201920612.NET Framework: 811. (번역글) .NET Internals Cookbook Part 1 - Exceptions, filters and corrupted processes [1]파일 다운로드1
11837정성태3/6/201933869기타: 74. 도서: 시작하세요! C# 7.3 프로그래밍 [10]
11836정성태3/5/201918079오류 유형: 525. Visual Studio 2019 Preview 4/RC - C# 8.0 Missing compiler required member 'System.Range..ctor' [1]
11835정성태3/5/201917529.NET Framework: 810. C# 8.0의 Index/Range 연산자를 .NET Framework에서 사용하는 방법 및 비동기 스트림의 컴파일 방법 [3]파일 다운로드1
... 76  77  [78]  79  80  81  82  83  84  85  86  87  88  89  90  ...