728x90

7Rules

 

Rule#1

Never ask Ava a question

if you must, ask a rhetorical question

 

Rule#2

Do not use difficult words that you are uncomfortable with.

Use simple words you are totally confident in using!

 

Rule#3

Try no to repeat the same word in the same sentence

 

Rule#4

Don't use 2 descriptive or feeling words using "and"

 

Rule#5

Talk about one thing, and one thing only!

 

Rule#6

If you get nervous and have nothing to say,

go right to the conclusion

 

Rule#7

Make "honest excuse" later.

Not in the begging!

 

방귀와 똥

 

방귀(fart)

fart 방구

door 문

문방구 : stationary store

 

1. let it rip /let one rip

I needed to let it rip

 

2. cut cheese

I was at StarBucks and all of a sudden I had to cut cheese.

 

3.thunder from down under

I was at the bar with my friends the other day, and all of a sudden

I felt a little thunder from down under.

 

4.slient but deadly

I cut cheese in the restuarnt, and I was hoping that no one would find out.

I mean, it was slient, but deadly

 

똥(poo)

1.number1 소변

 

2.number2 대변

 

3.take a dump

I felt like taking a dump during the the meeting.

Oh, the timing was terrible

 

4.deuce it

I had to deuce it[듀싯]

 

 

728x90
728x90

When I can't totally understand a question

1)I'm sorry[쒀리], but I think I should skip this question because I don't know what to say.

2)I mean.. I have no idea[아이디아] about this.

3)So I'll try and answer your next question

+So I'll try my best to answer your next question.

 

When I feel question so difficult

1)Oh, What? [Banks] in my country?

2)Are you serious? Are you kidding? Seriously?

3)Oh my gosh Eva, Why are you doing this to me?

4)I mean... That's very difficult[hard/tricky] question.

5)I can't believe you are asking about [the banks in my country]

+So I don't know what to say. I'll just skip this question!

 

When I have no thoughts about the topic

1)Honestly, I haven't thought about it[뚸ㅅ 어바우릿] at all.

2)I mean.. I'm not familiar[퍼밀리어] with this topic.

3)I seriously have no idea about this.

4)And you know what?

I'm not even interested in [technologies]

+I don't even go to banks

5)So, could you give me some time to think about it?

6)(3초뒤) Okay. Well. I'm soory but I still have no Idea.

7)So, If it's okay with you, I'd like to talk about _.

+I'd like to skip this question.

 

728x90
728x90
 

User-defined literals (C++)

Describes the purpose and use of user-defined literals in Standard C++.

docs.microsoft.com

c++에 리터럴 주요 6개 카테고리가 있습니다. : interger, character, floating-point, string, boolean, and pointer. C++11 부터는 당신은 이러한 카테고리에 기반하는 자신만의 리터럴을 정의 할 수 있다. 이것은 통상적인 관용어에 대한 구문적인 숏컷과 타입 안정성적을 증가 시키기 위한 것이다. 예를 들어 당신은 distance 클래스를 갖고 있다고 말해보자. 당신은 킬로미터와 또다른 마일에 대한 리터럴을 정의할 수 있을 것이다. 그리고 유저들에게 이러한 단위 대해 명확하게 하는 것을 권할 것이다. : auto d = 42.0_km 또는 auto d = 42.0_mi. 사용자 정의 리터럴에 대한 이점과 단점은 없습니다. 이것은 컴파일 타임 형식 추런이나 편의성을 우선적으로 합니다. 이러한 표준 라이브러리는 <chrono> 헤더에 std:;string, std::complex 그리고 시간과 기간 연산 대한 사용자 정의를 갖습니다.

Distance d = 36.0_mi + 42.0_km;         // Custom UDL (see below)
std::string str = "hello"s + "World"s;  // Standard Library <string> UDL
complex<double> num =
   (2.0 + 3.01i) * (5.0 + 4.3i);        // Standard Library <complex> UDL
auto duration = 15ms + 42h;             // Standard Library <chrono> UDLs

 

사용자 정의 리터럴 연산 기호

당신은 아래 형식중의 하나로 네임스페이스 범위 에서 operatr""를 이용해서 사용자 정의 리터럴을 구현합니다.

ReturnType operator "" _a(unsigned long long int);   // Literal operator for user-defined INTEGRAL literal
ReturnType operator "" _b(long double);              // Literal operator for user-defined FLOATING literal
ReturnType operator "" _c(char);                     // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _d(wchar_t);                  // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _e(char16_t);                 // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _f(char32_t);                 // Literal operator for user-defined CHARACTER literal
ReturnType operator "" _g(const char*, size_t);      // Literal operator for user-defined STRING literal
ReturnType operator "" _h(const wchar_t*, size_t);   // Literal operator for user-defined STRING literal
ReturnType operator "" _i(const char16_t*, size_t);  // Literal operator for user-defined STRING literal
ReturnType operator "" _g(const char32_t*, size_t);  // Literal operator for user-defined STRING literal
ReturnType operator "" _r(const char*);              // Raw literal operator
template<char...> ReturnType operator "" _t();       // Literal operator template

이전 예제의 연산자 이름은 당신이 제공하는 이름에 대한 플레이스 홀더 입니다. 앞에 언더스코어는 필수 입니다.(표준 라이브러리만 언더스코어 없이 리터럴을 정의하는 것이 가능합니다) 리턴 타입은 당신이 리터럴에 의해 수해오디는 변환이나 다른 연산자를 사용자 정의하는 곳입니다. 또한 이러한 연산들은 constexpr로도 정의될 수 있습니다.

 

Cooked Literals

소스코드에서 사용자 정의든 아니든 101 or 54.7, "hello", true 와 같은 알파벳 문자들 시퀀스는 필수적이다. 컴파일러는 시퀀스를 integer, float const char* string 등으로 해석한다. 컴파일러 리터럴 값으로 할당한 타입과 상관없이 입력으로 받아드려진 모든 사용자 리터럴 값은 비공식적으로 cook 리터럴로 알려진다. except _r 와 _t 위의 모든 연산자는 cooked literals이다. 예를 들어 리터럴 42.0_kim는 연산자를 _km로 바인드 시킨다. 그것은 _b 시그니처와 유사하다. 그리고 리터럴 42_kim는 연산자를 _a 시그니처와 비슷하게 바인딩 한다.

 

다음 예제넌 사용자 정의 리터럴이 호출자에게 사용자들의 입력에 대해 명확하게 할 것을 권하는 방법을 보여준다. Distance를 생성하기 위해서 우리는 반드시 kilometers 또는 milds를 적절한 사용자 리터럴을 사용하여 명확히 지정해야 한다. 당신은 다른 방법으로 같은 결과를 얻을 수 있다. 하지만 사용자 정의 리터럴은 다른 대안들 보다 간단한다.

// UDL_Distance.cpp

#include <iostream>
#include <string>

struct Distance
{
private:
    explicit Distance(long double val) : kilometers(val)
    {}

    friend Distance operator"" _km(long double val);
    friend Distance operator"" _mi(long double val);

    long double kilometers{ 0 };
public:
    const static long double km_per_mile;
    long double get_kilometers() { return kilometers; }

    Distance operator+(Distance other)
    {
        return Distance(get_kilometers() + other.get_kilometers());
    }
};

const long double Distance::km_per_mile = 1.609344L;

Distance operator"" _km(long double val)
{
    return Distance(val);
}

Distance operator"" _mi(long double val)
{
    return Distance(val * Distance::km_per_mile);
}

int main()
{
    // Must have a decimal point to bind to the operator we defined!
    Distance d{ 402.0_km }; // construct using kilometers
    std::cout << "Kilometers in d: " << d.get_kilometers() << std::endl; // 402

    Distance d2{ 402.0_mi }; // construct using miles
    std::cout << "Kilometers in d2: " << d2.get_kilometers() << std::endl;  //646.956

    // add distances constructed with different units
    Distance d3 = 36.0_mi + 42.0_km;
    std::cout << "d3 value = " << d3.get_kilometers() << std::endl; // 99.9364

    // Distance d4(90.0); // error constructor not accessible

    std::string s;
    std::getline(std::cin, s);
    return 0;
}

리터럴 숫자는 반드시 10진수를 사용한다. 그렇지 않으면 숫자는 정수형과 연산자와 호환 불가능한 타입으로 해석될 수 있다. 플로팅 포인 입력에서 타입은 반드시 long double 이여야 한다. 그리고 정수 타입에서는 반드시 longlong 타입이여야 한다.

 

예시: 로우 리터럴의 한계

로투 리터럴 연산자와 리터럴 연산자 템플릿은 오직 중서나 플로팅 포인트 사용자 정의 리터럴에서만 작동한다. 다른 예시에서 볼수 있듯이

#include <cstddef>
#include <cstdio>

// Literal operator for user-defined INTEGRAL literal
void operator "" _dump(unsigned long long int lit)
{
    printf("operator \"\" _dump(unsigned long long int) : ===>%llu<===\n", lit);
};

// Literal operator for user-defined FLOATING literal
void operator "" _dump(long double lit)
{
    printf("operator \"\" _dump(long double)            : ===>%Lf<===\n",  lit);
};

// Literal operator for user-defined CHARACTER literal
void operator "" _dump(char lit)
{
    printf("operator \"\" _dump(char)                   : ===>%c<===\n",   lit);
};

void operator "" _dump(wchar_t lit)
{
    printf("operator \"\" _dump(wchar_t)                : ===>%d<===\n",   lit);
};

void operator "" _dump(char16_t lit)
{
    printf("operator \"\" _dump(char16_t)               : ===>%d<===\n",   lit);
};

void operator "" _dump(char32_t lit)
{
    printf("operator \"\" _dump(char32_t)               : ===>%d<===\n",   lit);
};

// Literal operator for user-defined STRING literal
void operator "" _dump(const     char* lit, size_t)
{
    printf("operator \"\" _dump(const     char*, size_t): ===>%s<===\n",   lit);
};

void operator "" _dump(const  wchar_t* lit, size_t)
{
    printf("operator \"\" _dump(const  wchar_t*, size_t): ===>%ls<===\n",  lit);
};

void operator "" _dump(const char16_t* lit, size_t)
{
    printf("operator \"\" _dump(const char16_t*, size_t):\n"                  );
};

void operator "" _dump(const char32_t* lit, size_t)
{
    printf("operator \"\" _dump(const char32_t*, size_t):\n"                  );
};

// Raw literal operator
void operator "" _dump_raw(const char* lit)
{
    printf("operator \"\" _dump_raw(const char*)        : ===>%s<===\n",   lit);
};

template<char...> void operator "" _dump_template();       // Literal operator template

int main(int argc, const char* argv[])
{
    42_dump;
    3.1415926_dump;
    3.14e+25_dump;
     'A'_dump;
    L'B'_dump;
    u'C'_dump;
    U'D'_dump;
      "Hello World"_dump;
     L"Wide String"_dump;
    u8"UTF-8 String"_dump;
     u"UTF-16 String"_dump;
     U"UTF-32 String"_dump;
    42_dump_raw;
    3.1415926_dump_raw;
    3.14e+25_dump_raw;

    // There is no raw literal operator or literal operator template support on these types:
    //  'A'_dump_raw;
    // L'B'_dump_raw;
    // u'C'_dump_raw;
    // U'D'_dump_raw;
    //   "Hello World"_dump_raw;
    //  L"Wide String"_dump_raw;
    // u8"UTF-8 String"_dump_raw;
    //  u"UTF-16 String"_dump_raw;
    //  U"UTF-32 String"_dump_raw;
}
operator "" _dump(unsigned long long int) : ===>42<===
operator "" _dump(long double)            : ===>3.141593<===
operator "" _dump(long double)            : ===>31399999999999998506827776.000000<===
operator "" _dump(char)                   : ===>A<===
operator "" _dump(wchar_t)                : ===>66<===
operator "" _dump(char16_t)               : ===>67<===
operator "" _dump(char32_t)               : ===>68<===
operator "" _dump(const     char*, size_t): ===>Hello World<===
operator "" _dump(const  wchar_t*, size_t): ===>Wide String<===
operator "" _dump(const     char*, size_t): ===>UTF-8 String<===
operator "" _dump(const char16_t*, size_t):
operator "" _dump(const char32_t*, size_t):
operator "" _dump_raw(const char*)        : ===>42<===
operator "" _dump_raw(const char*)        : ===>3.1415926<===
operator "" _dump_raw(const char*)        : ===>3.14e+25<===
728x90
728x90
 

String and character literals (C++)

How to declare and define string and character literals in C++.

docs.microsoft.com

문자열 리터럴

문자열 리터럴은 널이 제거된 문자열을 형성하는 문자들 시퀀스를 함께 표현한다. 문자들은 반드시 쌍따옴표 안에 있어야한다. 다음에 문자열 리터럴의 종류가 있다.

 

좁은 문자열 리터럴

좁은 무자열 리터럴은 접두사가 없고 쌍따옴표로 구본되고, 널이 제거 된 const char[n] 타입의 배열이다. 여기서 n은 바이트 배열의 길이다. 좁은 문자열 리터럴은 싸따옴표, 백슬래쉬, 또는 개행 문자를 제외한 어떤 그래픽 문자도 포함할 수 있다. 좁은 문자열 리터럴은 또한 아래 정리된 이스케이프 시퀀스와 바이트에 맞는 범용 문자 이름 또한 포함 할수도 있다.

const char *narrow = "abcd";

// represents the string: yes\no
const char *escaped = "yes\\no";

 

UTF-8 encoded strings

A UTF-8로 인코딩된 문자열은 u8-접두사가 있고, 쌍따옴표로 구분되어 있고 const char[n] 타입의 배열이다. 여기서 n은 인코딩된 바이트 배열의 길이이다. u8 접두사가 있는 문자열 리터럴은 또한 쌍따옴표, 백슬래쉬, 개행문자를 제외하고 어떤 그래픽 문자도 가질 수 있다. u8 접두사가 붙은 문자열 리터럴은 또한 아래 정리된 이스케이프 시퀀스와 어떤 범용 문자 이름을 포함 할수도 있다.

 

C++20에서는 유연한 char8_t(UTF8로 인코딩된 8비트 유니코드)문자 타입을 소개한다. c++20에서 u8 리터럴 접두사들은 char 대신 char8_t 문자열과 문자들을 지정한다.

// Before C++20
const char* str1 = u8"Hello World";
const char* str2 = u8"\U0001F607 is O:-)";
// C++20 and later
const char8_t* u8str1 = u8"Hello World";
const char8_t* u8str2 = u8"\U0001F607 is O:-)";

 

넓은 문자열 리터럴

넓은 문자열 리터럴은 널이 없는 wchar_t배열이고 wchar_t는 L 접두사가 붙는다. 그리고 쌍따옴표, 백슬래쉬 또는 개행문자를 제외한 어떤 그래픽 문자든지 포함한다. 넓은 문자열 리터럴은 아래 정리된 이스케이프 문자 시퀀스들과 아무 범용 캐릭터 이름을 포함할 수도 있다.

const wchar_t* wide = L"zyxw";
const wchar_t* newline = L"hello\ngoodbye";

 

char16_t 와 char32_t(C++11)

C++11 은 편한 char16_6(16비트 유니코드)와 char32_t(23비트 유니코드) 문자 타입들을 소개한다.

auto s3 = u"hello"; // const char16_t*
auto s4 = U"hello"; // const char32_t*

 

raw 문자열 리터럴(C++11)

raw문자열 리터럴은 널이 제거된 아무 문자 타입의 배열이다. 그리고 쌍따옴표, 백슬래쉬 또는 개행문자를 포함하고 아무 그래픽 문자를 포함한다. 로우 문자열 리터럴은 캐릭터 클래스를 사용하는 정규식과 html 문자열, xml 문자열에 사용된다. 샘플에 대한건 다음 기사를 확인 하세요. Bjarne stroustrup's FAQ on C++ 11

// represents the string: An unescaped \ character
const char* raw_narrow = R"(An unescaped \ character)";
const wchar_t*  raw_wide  = LR"(An unescaped \ character)";
const char*     raw_utf8a = u8R"(An unescaped \ character)"; // Before C++20
const char8_t*  raw_utf8b = u8R"(An unescaped \ character)"; // C++20
const char16_t* raw_utf16 = uR"(An unescaped \ character)";
const char32_t* raw_utf32 = UR"(An unescaped \ character)";

구분자는 최대 16문자로 구성된 사용자 정의 시퀀스입니다. 구분자는 로우 스트릴 문자열의 열린 괄호 앞에 있고 그리고 닫힌 과로 뒤에 있습니다. 예를 들어 rR"abc(Hello"\()abc"에서 구분자 시퀀스 이고 문자열 내용은 Hello"\C 입니다. 당신은 당신은 로우 문자열을 명확하게 구분하는 구분자를 사용할수 있습니다. 로우 문자열은 쌍따옴표마크나 광호를 모두 포함합니다. 이런 문자열은 컴파일 에러를 일으킵니다.

// meant to represent the string: )"
const char* bad_parens = R"()")";  // error C2059

그러나 구분자는 이것을 해결합니다.

const char* good_parens = R"xyz()")xyz";

당신은 개행(이스케이프 문자가 아닌)을 포함하는 로우 문자열 리터럴을 구성할 수 있습니다.

// represents the string: hello
//goodbye
const wchar_t* newline = LR"(hello
goodbye)";

 

std::string literals(C++14)

std::string 리터럴은 "xyz"s(접미사 s)처럼 표현되는 사용장 정의 리터럴의 표준 라이브러리 구현들이다. 문자열 리터럴 종류는 std::string, std::wstring, std::u32string, 또는 std::u16string과 같은 임시 객체를 생성한다. 이들은 지정된 접두사에 의존적이다. 접두사 없이 사용될 때는 위처럼 std::string이 생성된다. L"xyz"s는 std::wstring을 생성한다. u"xyz"s는 std::u16string를 생성하고 U"xyz"는 std::u32string을 생성한다.

//#include <string>
//using namespace std::string_literals;
string str{ "hello"s };
string str2{ u8"Hello World" };     // Before C++20
u8string u8str2{ u8"Hello World" }; // C++20
wstring str3{ L"hello"s };
u16string str4{ u"hello"s };
u32string str5{ U"hello"s };

접미사 s는 저수준 문자열 리터럴에도 사용될 수 있다.

u32string str6{ UR"(She said "hello.")"s };

std::string 문자열은 <string> 헤더 파일 안에 std::literals::string_literals 네임스페이스 안에 정의되어 있다. std::literals:;string_literals와 std::literals 모두 인라인 네임스페이스로 선언되어 있기 때문에 std::literals::string_literals는 자동으로 std 네임스페이스에 직접 소유되는 것 처럼 취급됩니다.

 

문자열 리터럴의 사이즈

ANSI char* 문자열과 기타 단독 바이트 인코딩인 경우, 문자열 리터럴의 크기는 제거 널 문자에서 문자 숫자를 1더한 것이다. 모든 다른 문자열 타입의 경우 크기가 엄격히 문자 갯수와 관련되어 있지는 않다. UTF-8은 일부 코드 유닛을 인코드하기 위해서 char를 4개까지 사용한다. utf-16으로 인코드 된 그리고 char16_t나 wchar_t는 단독 코드 유닛을 인코드 하기 위해서 2개의 요소(총 4바이트)를 사용한다. 이 예제는 넓은 문자열 리터럴의 바이트 사이즈를 보여준다.

const wchar_t* str = L"Hello!";
const size_t byteSize = (wcslen(str) + 1) * sizeof(wchar_t);

strlen()과 scslen()은 종료 널 문자 사이즈를 포함하지 않고 사이즈는 문자열 타입의 요소 사이즈와 동일하다 : char* or char8_t* 문자열은 1바이트, wchar_t* 또는 char16_t* 문자열은 2바이트, char32_t* 문자열은 4바이트.

 

문자열 리터럴으 최대 길이는 65535 바이트이다. 이 최대치는 좁은 문자열 리터럴과 넓은 문자열 리터럴에 모두 적용된다.

 

문자열 리터럴 수정

문자열 리터럴(std:;string을 포함하지 않는)는 상수이기 때문에 그것들을 수정하는 것은(예시_str[2] = 'a') 컴파일 에러를 발생 시킨다.

 

마이크로소프트 관련

C++ 마이크로소프트에서 당신으 non-const char 또는 wchar_t 포인터를 초기화기 위해 사용할 수 있습니다. 이 non-const 초기화는 c99 에서 가능합니다. 하지만 이건 c++98에서 deprecate 됐고, C++11에서 제거 됐습니다. 문자열을 수정하는 시도는 예시처럼 접근 위반을 일으킵니다.

wchar_t* str = L"hello";
str[2] = L'a'; // run-time error: access violation

 

당신은 컴파일 옵션을 /Zc:strictStrings(Disable string literal type conversion)을 설정하고 non-const 문자 포인터로 문자열 리터럴을 번경하려고 하면 콤파일은 에러를 발생합니다. 우리는 표준을 따르는 포터블 코드를 따르는 방법을 추천합니다. 이것은 문자열 리터럴 초기화 포인터를 선언하기 위한 auto 키워드를 사용하는 좋은 연습입니다. 왜냐하면 이것은 정확한 타입으로 해결합니다. 예를 들어 아래 코드 샘플은 컴파일 타임에 문자열 리터럴을 쓰는 시도를 잡아 냅니다.

auto str = L"hello";
str[2] = L'a'; // C3892: you cannot assign to a variable that is const.

어떤 경우에는 실행파일에서 공간을 절약하기 위해 동일한 문자열 리터럴은 풀링된다. 문자열 리터럴 풀링에서 컴파일러는 특정 문자열 리터럴의 모든 참조가 메모리 상의 같은 위치를 가리키게 합니다. 문자열 리터럴에 개별의 인스턴스에 대한 각각의 참조를 갖는 대신에. 문자열 풀링을 하기 위해 컴파일러 옵션 /GF를 사용해라.

 

마이크로소프트 관련 섹션은 여기서 끝.

 

인접한 문자열 리터럴의 연결

인접한 넓은 또는 좁은 문자열 리터럴은 연결된다. 여기 선언은:

char str[] = "12" "34";

다음 선언과 동일하다.

char atr[] = "1234";

그리고 이 선언과도 동일하다.

char atr[] =  "12\
34";

문자열 리터럴을 지정하기 위해 내장 16진수 이스케이프 코드를 쓰는 것은 예기치 못한 결과를 일으킨다. 다음 예제는 ascii 5 문자를 초함하는 문자열 리터럴을 만들려고 한다. 그 다음 f,i,v 그리고 e를 만듭니다.

"\x05five"

실제 결과는 아스키 코드 언더스코어 16진수 5f 그리고 i, v, e 이다. 정확한 결과를 얻기 위해서는 당신은 이러한 이스케이프 시퀀스중 하나를 사용할 수 있다.

"\005five"     // Use octal literal.
"\x05" "five"  // Use string splicing.

std::string 리터럴(std::ustring, std::u16string, ste:;u32string과 관련된) 은 basic_string 타입으로 지정된 + 연산자를 통해 연결된다. 그들은 인접한 문자열 리터럴 또한 같은 방식으로 연결된다, 아래 모든 경우, 인코딩 문자열과 접미사는 반드시 매치되어야 한다.

auto x1 = "hello" " " " world"; // OK
auto x2 = U"hello" " " L"world"; // C2308: disagree on prefix
auto x3 = u8"hello" " "s u8"world"z; // C3688, disagree on suffixes

 

범용 문자 이름과 문자열 리터럴

네이티브(raw가 아닌) 문자열 리터럴은 범용 문자 이름이 하나 이상의 문자열 타입으로 인코딩 될수 있는 한 어떤 문자를 표현하기 위해서 범용 캐릭터 문자를 사용할 수도 있습니다. 예를 들어 확장 문자를 표현하는 범용문 자이름은 ansi 코드 페이지를 사용하는 좁은 문자열로 인코딩될 수 었습니다. 그러나 이것은 일부 멀티 바이트 코드 페이지나 utf8문자열 또는 넓은 문자열에서 좁은 문자열로 인코딩 될수 있습니다. c++11에서는 유니코드 서포토는 char16_t 그리고 char32_t 문자열 타입까지 확장되었습니다. 그리고 c++20은 char8_t까지 확장 시킵니다.

// ASCII smiling face
const char*     s1 = ":-)";

// UTF-16 (on Windows) encoded WINKING FACE (U+1F609)
const wchar_t*  s2 = L"😉 = \U0001F609 is ;-)";

// UTF-8  encoded SMILING FACE WITH HALO (U+1F607)
const char*     s3a = u8"😇 = \U0001F607 is O:-)"; // Before C++20
const char8_t*  s3b = u8"😇 = \U0001F607 is O:-)"; // C++20

// UTF-16 encoded SMILING FACE WITH OPEN MOUTH (U+1F603)
const char16_t* s4 = u"😃 = \U0001F603 is :-D";

// UTF-32 encoded SMILING FACE WITH SUNGLASSES (U+1F60E)
const char32_t* s5 = U"😎 = \U0001F60E is B-)";
728x90
728x90

렌더링파이프라인

테설레이션 스테이지는 다렉11에서 추가 됨

geometry shader stage 다렉10에서 추가 됨

테설레이션 스테이지과 지오메트리 쉐이이더는 정점을 추가하는 일을 한다.

 

다이렉트x란?

gpu 외주 라이브러리

 

장치 초기화를 위한 기본 요소

Device

 

CommandQueue

 

SwapChain

 

DescriptorHeap

728x90
728x90

하나의 시작점으로 구성된 트리에 간선을 하나씩 수집하며 진행

MST를 만들 수 있다.

 

다익스트라는 시작점을 기준 최단 cost

프림은 트리(정점집합)을 기준 최단 cost

728x90
728x90

 

 

String and character literals (C++)

How to declare and define string and character literals in C++.

docs.microsoft.com

C++ 은 다양한 문자열과 문자 타입을 지원하고 이러한 타입의 각각의 리터럴 값을 표현하는 방식을 제공합니다. 당신 코드에서 당신은 문자열 셋을 사용하는 문자와 문자열 리터럴 내용을 표현할 수 있습니다. 유니버스 문자 이름들과 이스케이프 문자들은 당신이 단지 기본 문자열 셋을 사용하면서 어떤 문자열이든 표현하게 합니다. 저수준 리터럴은 당신이 이스케이프 문자열을 피하거나 문자열 리터럴의 모든 유형을 표현하게 합니다. 당신은 또한 std::string 문자열을 추가적인 구성이나 변환 절차 없이 만들 수 있습니다.

#include <string>
using namespace std::string_literals; // enables s-suffix for std::string literals

int main()
{
    // Character literals
    auto c0 =   'A'; // char
    auto c1 = u8'A'; // char
    auto c2 =  L'A'; // wchar_t
    auto c3 =  u'A'; // char16_t
    auto c4 =  U'A'; // char32_t

    // Multicharacter literals
    auto m0 = 'abcd'; // int, value 0x61626364

    // String literals
    auto s0 =   "hello"; // const char*
    auto s1 = u8"hello"; // const char*, encoded as UTF-8
    auto s2 =  L"hello"; // const wchar_t*
    auto s3 =  u"hello"; // const char16_t*, encoded as UTF-16
    auto s4 =  U"hello"; // const char32_t*, encoded as UTF-32

    // Raw string literals containing unescaped \ and "
    auto R0 =   R"("Hello \ world")"; // const char*
    auto R1 = u8R"("Hello \ world")"; // const char*, encoded as UTF-8
    auto R2 =  LR"("Hello \ world")"; // const wchar_t*
    auto R3 =  uR"("Hello \ world")"; // const char16_t*, encoded as UTF-16
    auto R4 =  UR"("Hello \ world")"; // const char32_t*, encoded as UTF-32

    // Combining string literals with standard s-suffix
    auto S0 =   "hello"s; // std::string
    auto S1 = u8"hello"s; // std::string
    auto S2 =  L"hello"s; // std::wstring
    auto S3 =  u"hello"s; // std::u16string
    auto S4 =  U"hello"s; // std::u32string

    // Combining raw string literals with standard s-suffix
    auto S5 =   R"("Hello \ world")"s; // std::string from a raw const char*
    auto S6 = u8R"("Hello \ world")"s; // std::string from a raw const char*, encoded as UTF-8
    auto S7 =  LR"("Hello \ world")"s; // std::wstring from a raw const wchar_t*
    auto S8 =  uR"("Hello \ world")"s; // std::u16string from a raw const char16_t*, encoded as UTF-16
    auto S9 =  UR"("Hello \ world")"s; // std::u32string from a raw const char32_t*, encoded as UTF-32
}

 

문자열 리터럴은 접두사가 없거나 좁은 범위 문자 utf-8, 넓은 범위 문자 utf16,utf32 인코딩과 같은 제각각의 u8, L, u 접두사를 사용합니다. 저수준 문자열 리터럴은 이러한 인코딩의 저 수준으로 대응되는 r, u8r, lr, ur과 같은 접두사를 갖을 수 있습니다. 임시거나 정적 std::string 값을 만들기 위해서 당신은 문자열 리터럴 또는 저수준 리터럴을 s 접미사와 같이 쓸 수 있습니다. 더 많은 정보는 아래에 String Literals를 보세요. 더 많은 기본 문자열 집합이나 유니버스 문자열 이름, 당신 소스코드에 확장된 코드페이지 캐릭터 사용에 대한 것은 Character sets를 보세요.

 

Character Literals

캐릭터 리터럴은 상수 캐릭터로 구성됩니다. 이것은 따옴표에 둘러쌓인 문자들로 표현됩니다. 다섯가지 종류의 문자 리터럴이 있습니다.

- char의 오리지널 문자 리터럴, 예시 'a'

- char(C++20에서는 char8_t) 타입의 utf8 문자 리터럴, 예시 u8'a'

- wchar_t 의 넓은 문자 리터럴, 예시 L'a'

- char16_t의 utf-16 문자 리터럴, 예시 u'a'

- char32_t의 utf-32 문자 리터럴, 예시 U'a'

 

문자 리터럴에 사용되는 문자는 예약된 \,', 뉴라인을 제외하면 어떤 문자도 될수 있다. 예약된 문자들은 이스케이프 시퀀스로 지정될 수 있다. 문자들 범용문자 이름으로 지정된다. 그 타입이 문자를 포함할 만큼 충분히 크다면.

 

인코딩

문자 리터럴은 그들의 접두사를 기반으로 다르게 인코딩됩니다.

 

- 접두사가 없는 문자는 오리지널 문자 리터럴 입니다. 문자셋 실행에서 표현되는 싱글 문자나, 이스케이프 문자 또는 범용 문자 이름을 포함하는 문자 리터럴의 오리지널 값은 문자셋 실행에서 인코딩의 숫자값과 동일합니다. 하나 이상 문자, 이스케이프시퀀스 또는 범용 문자 이름을 포함하는 오리지널 문자는 멀티문자 리터럴입니다. 실행 문자 세트에서 표현할 수 없는 멀티 문자 리터럴 또는 일반 문자 리터럴은 type int 와 이며 그 값은 구현 정의 입니다. MSVC에 대해서는 아래 Microsoft-specific section을 보세요.

 

- 접두사 L로 시작하는 캐릭터 리터럴은 광범위한 문자 리터럴이다. 싱글 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 광범위한 문자 리터럴 값은 문자 리터럴이 와이드 문자셋에서 표현되지 않는한 와이드 캐릭터 문자셋 실행에서 인코딩 수치 값과 동일합니다. 단 이경우 값은 구현정의됩니다.멀티 문자들과 이스케이프 시퀀스 또는 범용 캐릭터 이름을 포함하는 와이드 캐릭터 문자열의 값은 구현정의입니다. MSVC에 대해서는 아래 Microsoft-specific 섹션을 보세요.

 

- u8 접두사로 시작하는 문자 리터럴은 utf8 문자 리터럴이다. 싱글 문자, 이스케이프 시퀀스 또는 범용 캐릭터 이름을 포함하는 utf8 문자 리터럴 값은 utf8 코드 단독 코드 단위로 표현된다면 iso 10646 코드 포인트와 동일한 값을 갖는다. (C0 Control 과 기본 라틴 유니코드 블록에 해당).  단독 utf8 코드 단위로 표현되지 않는 값은 잘못된 형식입니다. 하나 이상의 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 utf8 문자 리터럴은 잘못된 형식입니다.

 

- u 접두사로 시작하는 문자 리터럴은 utf16 문자 리터럴이다. 단독 문자, 이스케이프 시퀀스, 또는 범용 캐릭터 이름을 포함하는 utf16값은 iso 10646 코드 포인트와 동등하다. 만약 그것이 단독 utf16코드 단위로 표현되었다면. (기본 멀티 2중 언어 플레인에 대응하는) 만약 그 값이 단독 utf16 코드 단위르롤 표현하지 않는다면 그것은 잘못된 형식이다. 하나의 이상의 문자, 이스케이프 문자열 또는 범용 문자 이름을 포함하는 utf16문자 리터럴은 잘못된 형식이다.

 

- U 접두사로 시작하는 문자 리터럴은 utf-32 문자 리터럴이다. 단독 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 utf32 문자 리터럴 값은 iso 10646 코드 포인트 값과 동일하다. 하나 이상의 문자, 이스케이프 시퀀스, 범용 문자 이름을 포함하는 utf32 문자 리터럴은 잘못된 형식이다.

 

Escape sequences

세 종류의 이스케이프 시퀀스가 있다. simple, octal, and hexidecimal. 이스케이프 시퀀스는 다음값 중 하나가 될 수 있다.

newline \n
backslash \\
horizontal tab \t
question mark ? or \?
vertical tab \v
single quote \'
backspace \b
double quote \"
carriage return \r
the null character \0
form feed \f
octal \ooo
alert (bell) \a
hexadecimal \xhhh

octal 이스케이프 시퀀스는 백슬래쉬 이후의 하나에서 세개의 8진수가 나오는 시퀀스이다. octal 이스케이프 시퀀스는 세번째 진수 전에 8진수가 아닌 문자를 만난다 면 그 처음 문자에서 종료됩니다. 8진수 값의 가장 큰값은 \377입니다.

 

16진수 이스케이프 시퀀스는 백슬래쉬 다음에 x 그 다음에 하나 이상의 16진수가 옵니다. 앞의 0은 무시된다. 일반문자나 u8 접두사 캐릭터 리터럴에서 최대 16진수 값은 0xFF이다. L 또는 u 넓은 캐릭터 리터럴에서의 최대 16진수 값은 0xFFFF 이다. U 접두사 넓은 캐릭터 맅럴에서 최대 16진수 값은 0xFFFFFF이다.

 

다음 샘플 코드는 일반문자 리터럴을 사용하는 이스케이프 캐릭터 예제를 보여준다. 다른 문자 리터럴 타입에도 동일한 이스케이프 시퀀스 구분은 유효합니다.

 

#include <iostream>
using namespace std;

int main() {
    char newline = '\n';
    char tab = '\t';
    char backspace = '\b';
    char backslash = '\\';
    char nullChar = '\0';

    cout << "Newline character: " << newline << "ending" << endl;
    cout << "Tab character: " << tab << "ending" << endl;
    cout << "Backspace character: " << backspace << "ending" << endl;
    cout << "Backslash character: " << backslash << "ending" << endl;
    cout << "Null character: " << nullChar << "ending" << endl;
}
/* Output:
Newline character:
ending
Tab character:  ending
Backspace character:ending
Backslash character: \ending
Null character:  ending
*/

백슬래쉬 문자는 라인 끝에 위치 하면 라인 지속 문자인다. 만약 당신이 백슬래쉬를 캐릭터 리터럴로 표현하길 원한다면 당신은 반드시 행에 2개의 백슬래쉬를 사용해요한다. 라인 지속 문자에 대해 더 알고 싶으면 봐라 Phase of Thranslation

 

마이크로소프트 관련

좁은 멀티문자 리터럴에서 값을 만들기 위해서는 컴파일러는 문자나 문자 시퀀스를 반점 사이에서 32bit integer에서 8bit로 변경합니다. 리터럴에 멀티 문자는 높은 순에서 낮은순으로 요구되는 바이트에 대응하여 채웁니다. 그리고 컴파일러는 정수형을 보통의 규칙에 따라 목적지 타입으로 변경합니다. 예를 들어 char 값을 만들기 위해서 컴파일러는 낮은 순서의 byte를 갖습니다. wchar_t, char16_t를 만들기 위해서는 컴파일러는 낮은 순서 워드를 갖습니다. 컴파일러는 어떤 비티는 할당돤 바이트나 워드 위에 설정된다면 결과는 잘릴 수 있다고 경고합니다.

char c0    = 'abcd';    // C4305, C4309, truncates to 'd'
wchar_t w0 = 'abcd';    // C4305, C4309, truncates to '\x6364'
int i0     = 'abcd';    // 0x61626364

 

3개이상의 진수를 포함하는 것을 나타내는 8 이스케이프 시퀀수는 3 진수 8 시퀀스로 다뤄집니다. 그 다음 진수는 멀티문자 리터럴에 문자로 취급됩니다. 그것은 놀라운 결과를 나타냅니다. 예시.

char c1 = '\100';   // '@'
char c2 = '\1000';  // C4305, C4309, truncates to '0'

8진수가 아닌 문자를 포함하는 걸로 보이는 이스케이프 시퀀스는 마지막 8진수 문자까지 8진수 시퀀스로 평가됩니다. 그다음 남은 문자들은 다중 문자 리터럴의 후속 문자로 평가됩니다. 만약 첫 8진수가 아닌 문자가 10진수라면 c4125 경고가 발생합니다. 예시

char c3 = '\009';   // '9'
char c4 = '\089';   // C4305, C4309, truncates to '9'
char c5 = '\qrs';   // C4129, C4305, C4309, truncates to 's'

\377보다 더 큰 8진수 이스케이프 시퀀수는 에러 c2022를 발생합니다. '10진수값":매우 큰 문자.

 

16진수나 16진수가 아닌 문자를 갖은 것으로 보이는 이스케이프 시퀀스는 마지막 16진수 문자까지 16진수를 포함하는 멀티 문자로 평가됩니다. 16진수를 포함하지 않는 16진수 이스케이프 시퀀스는 컴파일 에러 c2153을 발생 시킵니다. "16진수 리터럴은 반드시 최소한 하나의 16진수를 가져야 한다"

char c6 = '\x0050'; // 'P'
char c7 = '\x0pqr'; // C4305, C4309, truncates to 'r'

L접두사가 붙는 광범위 문자가 멀티문자 시퀀스를 포함한다면 그 값은 첫번째 값으로 값이 매겨지거나, 컴파일러가 경고 c4066을 발생시킨다. 후속 문자들은 무시된다 본래 멀티문자 리터럴의 동등한 동작과 달리 후속 문자들은 무시됩니다.

wchar_t w1 = L'\100';   // L'@'
wchar_t w2 = L'\1000';  // C4066 L'@', 0 ignored
wchar_t w3 = L'\009';   // C4066 L'\0', 9 ignored
wchar_t w4 = L'\089';   // C4066 L'\0', 89 ignored
wchar_t w5 = L'\qrs';   // C4129, C4066 L'q' escape, rs ignored
wchar_t w6 = L'\x0050'; // L'P'
wchar_t w7 = L'\x0pqr'; // C4066 L'\0', pqr ignored

마이크로 소프트 관련 섹션은 여기 맨 끝에

 

범용 문자 이름들

문자 리터럴과 네이티브 문자열 리터럴에서 어떤 문자나 범용 문자 이름을 나타낼 수 있다. 범용 문자 이름은 \U 접두사를 갖고 그 다음 8진수 유니코드 포인트가 오거나 \u접두사를 갖고 그다음 4진수 유니코드 포인트가 오는 형식을 갖는다. 모든 8진수 4진수는 개별적으로 더 나은 유니버셜 문자 이름 형식을 만들기 위해 제시된다.

wchar_t w1 = L'\100';   // L'@'
wchar_t w2 = L'\1000';  // C4066 L'@', 0 ignored
wchar_t w3 = L'\009';   // C4066 L'\0', 9 ignored
wchar_t w4 = L'\089';   // C4066 L'\0', 89 ignored
wchar_t w5 = L'\qrs';   // C4129, C4066 L'q' escape, rs ignored
wchar_t w6 = L'\x0050'; // L'P'
wchar_t w7 = L'\x0pqr'; // C4066 L'\0', pqr ignored

대리 페어

범용 문자 이름은 대리 코드 포인트 범위 D8000-DFFF에서 값을 인코드 하지 않습니다. 유니코드 대리 쌍에서 특히 \UNNNNNNNN을 사용한 범용문자이름에서 NNNNNNNN은 문자에 대한 8진수 코드 입니다. 컴파일러는 필요하다면 대리 페어를 생성합니다.

 

C++ 03에서 일부 문자에만 범용문자이름을 나타나 내느 것을 허용 했고 일부 범용문자이름은 실제로 일부 적합한 유니코드 문자들을 표현하는 것이 불가능합니다. 이런 실수는 c++11 기준에 수정되었습니다. C++11에서는 문자 그리고 문자열 리터럴 그리고 식별자까지 모두 범용 문자 이름을 사용할 수 있습니다. 범용문자이름에 대한 더 많은 정보는 CharacterSets을 참고하세요. 유니코드에 대한 정보는 Unicode를 보세요. 대리쌍에 대한 더많은 정보는 Surrogate Pairs and Supplementary Characters를 보세요.

 

 

728x90
728x90

As I told you before~

전에 얘기 했지만

728x90

'English' 카테고리의 다른 글

영어 메일 첫인사 및 서두인사 호칭  (0) 2022.03.10
관계 대명사 that을 쓰는 경우  (0) 2021.10.17
728x90

https://docs.microsoft.com/en-us/cpp/cpp/numeric-boolean-and-pointer-literals-cpp?view=msvc-160 

 

Numeric, boolean, and pointer literals (C++)

The C++ standard language formats for integer, floating-point, boolean, and pointer literals.

docs.microsoft.com

 

리터럴은 값을 직접 표현하는 프로그램 요소입니다. 이 기사는 interger 타입, 부동소수점, 불리언, 포인터의 리터럴들을 설명합니다. 문자열과 캐릭터 리터럴들에 대한 정보는 여길 String and Character Literals(C++)을 확인하세요. 당신은 또한 이러한 카테고리중에 기초하여 자신의 리터럴을 정의할 수도 있습니다. 더 많은 정보는 User-defined Literals(C++)을 참고하세요.

const int answer = 42;      // integer literal
double d = sin(108.87);     // floating point literal passed to sin function
bool b = true;              // boolean literal
MyClass* mc = nullptr;      // pointer literal

 

때로 컴파일러에게 리터럴을 해석하거나 리터럴에 부여할 특정 유형을 알려주는 것은 중요합니다. 이것은 리터럴의 접두사나 접미사를 붙이면 됩니다. 예를 들어 접두사 0x 는 컴파일레에게 숫자를 16진수 값으로 해석하도록 합니다. (ex  example 0x35).  ULL 접미사는 컴파일레에게 5894345ULL 처럼 unsignedLongLong 값으로 처리하도록 합니다. 각 리터럴 타입의 데한 접두사와 접미사 목록을 알고 싶으면 다음 섹션을 보세요.

 

Interger Literals

정수형 리터럴은 숫자로 시작되고 분수나 지수 부분이 없습니다. 당신은 정수형 숫자를 십진수, 이진수, 16진수 형태로 지정할 수 있습니다. 당신은 선택적으로 정수형 리터럴을 unsigned 형태로 지정할 수 있고 접미사를 사용하여 long이나 longlong과 같은 타입으로 지정할 수도 있습니다.

 

접두사, 접미사가 없는 현제 컴파일러는 정수형 리터럴 타입을 int로 지정합니다. 그 값이 맞다면, 그렇지 않으면 long long 타입으로 지정합니다.

 

십진수 정수형 리터럴로 지정하기 위해서 nonzero digit을 지정하는 것을 시작해라. 예시.

int i = 157;        // Decimal literal
int j = 0198;       // Not a decimal number; erroneous octal literal
int k = 0365;       // Leading zero specifies octal literal, not decimal
int m = 36'000'000  // digit separators make large values more readable

 

8진수 integral 리터럴로 지정은 0으로 시작하고 그뒤에 0에서 7사이의 숫자가 놓인다. 8과 9는 8진수 리터럴을 지정할 때 에러이다. 아래 예시

int i = 0377;   // Octal literal
int j = 0397;   // Error: 9 is not an octal digit

16진수 정수 리터럴을 지정하기 위해서는 0x 나 0X로 시작하고(x의 대/소는 상관없음) 뒤에 0에서 9 그리고 a/A에서 f/F 범위 내에서 숫자가 온다. 16진수 a/A ~ f/F는 10~15값을 표현한다. 아래 예시

int i = 0x3fff;   // Hexadecimal literal
int j = 0X3FFF;   // Equal to i

숫자 구분자 : 당신은 따옴표 문자를 이용하여 사람이 읽기 편하게 커다란 숫자의 공간을 구분할 수 있습니다. 구분자는 컴파일에 아무런 영향을 주지 않습니다.

long long i = 24'847'458'121

 

부동 소수점 리터럴

부동소수점 리터럴은 분수부분을 같는 값을 지정합니다. 이러한 값들은 소수점(.)을 포함하고 지수를 포함합니다.

 

부동소수점 리터럴은 숫자의 값을 지정하는 가수를 갖는다. 또한 숫자의 크기를 나타내는 지수부를 갖습니다. 그리고 그들은 선택적인 중위표현식을 갖습니다. 그것은 리터럴 타입을 지정합니다. 가수부는 마침표 앞에오는 숫자들이 거나 숫자의 분을 나타내는 숫자들로 지정됩니다.  아래 예시

18.46
38.

지수는 아래 예제에서와 같이 10의 거듭제급으로 숫자의 크기를 지정합니다

18.46e0      // 18.46
18.46e1      // 184.6

지수는 e 또는 e를 사용하여 지정될 수 있고, 그것들은 같은 의미를 갖습니다. 그 다음에 옵션으로 +또는 -기호와 숫자 순서를 사용할 수 있습니다. 만약 지수가 존재하면 추적하는 소수점은 18E0과 같은 숫자에서 필요 없다.

 

부동소수점 리터럴은 double 타입을 기본으로 한다. 접미사 f 또는 l 또는 F 또는 L를 (대소문자는 상관없다)  사용하여 리터럴은 float나 longdouble로 지정될 수 있다.

 

비록 longdouble과 double은 같은 표현을 하지만 그들은 같은 표현이 아니다. 예를 들어 당신은 이와 같이 오버로드 할수 있다.

void func( double );

그리고

void func( long double );

 

불리언 리터럴

불리언 리터럴은 true와 false이다.

 

포인터 리터럴(C++11)

C++ 0 초기화 포인터를 지정하는 nullptr을 소개합니다. 유연한 코드에서는 nullptr가 정수형 0이나 매크로 NULL 대신에 사용 되어야합니다.

 

이진 리터럴(C++14)

이진 리터럴은 0b 나 0B를 사용하여 지정됩니다. 그 다음에 1과 0의 숫자 순서가 업니다.

auto x = 0B001101 ; // int
auto y = 0b000001 ; // int

 

매직 상수로서의 리터럴을 피하라

당신은 직접적으로 표현식이나 구문을 사용할 수 있다. 비록 그게 항상 좋은 프로그래밍 방식이 아니라고 해도.

if (num < 100)
    return "Success";

앞에 예시에서 더 나은 방식은 이름이 있는 상수(명확한 의미를 전달하는)를 사용하는 것이다. 예를 들어 "MAXIMUM_ERROR_THRESHOLD"와 같은. 만약 마지막 사용자가 "Success"라는 리턴 값을 본다면 명명된 문자열 상수를 쓰는게 더 좋을 수 있다. 당신은 다른 언어로 번역가능한 파일의 단독 위치에 문자열 상수를 사용할 수 있다. 명명된 상수를 사용하는것은 당신과 다른 사람들에게 코드의 의도를 이해하는데 도움을 준다.

728x90
728x90

특징에 대해 설명 하세요

-

-

 

구현 flow에 대해 설명하세요

-

-

 

직접 구현하기

C++

728x90
728x90

스패닝 트리에  대해 설명하시오

-

-

 

최소스패닝트리에 대해 설명하시오

-

-

 

728x90
728x90

DisjointSet 자료구조의 특징

-

-

 

시간 복잡도

-

 

용도

-

 

경로압축의 원리는?

-

 

링크압축의 원리는?

-

 

직접 구현 해보기

C++

 

728x90
728x90
 

Punctuators (C++)

Learn more about: Punctuators (C++)

docs.microsoft.com

 

c++ 에서 구두점은 컴파일러에게 구문, 의미적으로 의미를 갖지만, 값을 산출하는 연산을 지정하지는 않습니다. 일부 혼자 쓰이거나 조합되어 쓰이는 구두점은 또한 c++ 연산자로 쓰이거나, 전처리기로 중요한 역할을 합니다.

 

다음 문자들은 구두점들이다.

! % ^ & * ( ) - + = { } | ~
[ ] \ ; ' : " < > ? , . / #

구두점 [],() 그리고 {}은 반디스 translation phase 뒤에 쌍으로 나타나야 합니다.

 

728x90
728x90

https://www.fluentu.com/blog/english-kor/%EC%98%81%EC%96%B4-%EC%B6%94%EC%9E%84%EC%83%88/

 

영어 추임새: 생소하지만 알아두면 아주 유용한 Filler words 15개

“well”, “um”, "like"과 같은 영어 추임새(filler words)는 문장에 실질적인 의미를 부여하지는 않지만 문장의 톤을 바꾸는 역할을 하는데요, 미국에서 가장 자주 쓰이는 영어 추임새 15가지를 한번

www.fluentu.com

미국식 영어에서 꼭 알아야 할 15가지 영어 추임새(filler words)

1. Well

“Well”은 여러 가지 용도로 쓰입니다. 먼저, 당신이 지금 생각하는 중이라는 것을 보여줄 때 사용할 수 있습니다.

Well, I guess $20 is a good price for a pair of jeans.”

말을 하는 중간에 잠시 쉬어갈 때도 쓸 수 있습니다.

“The apples and cinnamon go together like, well, apples and cinnamon.”

그리고 심지어 단순히 시간을 벌기 위해서도 쓸 수 있습니다.

Well… fine, you can borrow my car.”

2. Um/er/uh

“Um”, “er”, “uh”는 망설일 때 가장 많이 쓰이는 표현입니다. 정답을 잘 모를 때, 혹은 대답하고 싶지 않을 때 쓸 수 있죠.

Um, er, I uh thought the project was due tomorrow, not today.”

셋을 동시에 쓸 필요는 없으며 원할 때 아무거나 하나를 골라 사용해도 좋습니다.

Umm… I like the yellow dress better!”

3. Hmm

“Hmm”은 생각하는 중일 때 나오는 소리입니다. 당신이 고민 중이라거나 무언가를 결정하는 중이라는 걸 표현하죠.

Hmm, I like the pink bag but I think I’ll buy the black one instead.”

4. Like

“Like”는 정확한 정보가 아니라, “그 비슷한”, “그 언저리의”라는 뜻으로 쓰입니다.

“My neighbor has like ten dogs.”

위의 예문에서 이웃이 정확히 10마리의 개를 키우고 있는지는 확실하지 않습니다. 그냥 개의 마릿수가 많은 것이죠.

그리고 like는 말을 하는 도중 이다음에 쓸 말을 생각해내기 위해 시간을 조금 벌어야 할 때도 자주 사용됩니다.

“My friend was like, completely ready to like kick me out of the car if I didn’t stop using the word ‘like’.”

영어 추임새 용도의 “like”는 영어 원어민들 사이에서 일반적으로 부정적인 인식이 있습니다. 주로 나이 어린 여자들이 문맥과 상황을 고려하지 않고 남용하는 경향이 있고, 또 이렇게 like를 과하게 사용하다 보면 본인이 하는 말에 확신이 없다는 이미지를 줄 수 있기 때문입니다.

5. Actually/Basically/Seriously

“Actually”, “basically”, “seriously”는 모두 부사입니다. 동사를 꾸며주는 역할을 하죠. 많은 부사 단어 끝에는 “-ly”가 있기 때문에 알아보기도 쉽습니다. 이 모든 단어들은 말 어감상의 변화를 줄 때 추임새로서 쓰일 수 있습니다.

예를 들어 “actually” 같은 경우, 남들은 아니라고 할 수도 있지만 당신이 진실이라고 생각하는 것을 가리킬 때 사용할 수 있습니다:

Actually, pugs are really cute!”

“Basically”와 “seriously”는 문장을 살짝 다른 방향으로 틀어 주는 역할을 합니다. “Basically”는 무언가를 요약할 때 쓰고, “seriously”는 지금 하는 말을 진심으로 하는 것임을 표현할 때 쓸 수 있습니다.

Basically, the last Batman movie was seriously exciting!”

추임새로 쓰이는 다른 부사로는 “totally”, “literally”, “clearly” 등이 있습니다.

  • “literally”는 “글자 그대로”라는 의미가 있지만 대부분의 경우 대화에서는 다른 의미로 쓰입니다. 아주 강한 감정을 표현할 때 쓰이죠. 예: you’re not just laughing you’re literally dying from laughter.
  • “Totally”는 “completely”와 동의어이고 무언가에 대해 강조할 때 쓰입니다.
  • “clearly”는 obviously와 동의어이고 무언가가 명백하게 진실일 때 사용되는 말입니다.

이 세 단어 역시 한꺼번에 사용할 필요는 없지만 아래 예문에서는 여러분의 이해를 돕기 위해 한 곳에 넣어봤습니다:

Clearly you totally didn’t see me, even though I was literally in front of your face.”

6. You see

“You see”는 청자가 모르고 있다고 생각하는 사실을 공유할 때 사용됩니다.

“I was going to try the app, but you see, I ran out of space on my phone.”

7. You know

“You know”는 청자가 이미 알고 있을 거라고 생각하는 어떤 사실을 말할 때 사용됩니다.

“We stayed at that hotel, you know, the one down the street from Times Square.”

청자가 당신이 하는 말을 이해했다고 느꼈을 경우 긴 설명 대신 이 한마디로 대신할 수 있습니다.

“When the elevator went down, I got that weird feeling in my ears, you know?

8. I mean

“I mean”은 무언가에 대한 당신의 생각과 의도를 명확히 하고 싶을 때 씁니다.

I mean, he’s a great guy, I’m just not sure if he’s a good doctor.”

또는 앞서 말을 잘못했을 경우 이를 정정할 때도 쓰입니다.

“The duck and the tiger were awesome but scary. I mean, the tiger was scary, not the duck.”

“The cave is two thousand—I mean—twenty thousand years old!”

9. You know what I mean?

“You know what I mean?”은 내가 하는 말을 청자가 잘 따라오고 있는지 확인차 물을 때 쓰는 말입니다.

“I really like that girl, you know what I mean?

10. At the end of the day

“At the end of the day”는 “in the end” 또는 “in conclusion”의 동의어입니다.

At the end of the day, we’re all just humans, and we all make mistakes.”

11. Believe me

“Believe me”는 자기가 하는 말을 믿으라는 의미에서 하는 말입니다.

Believe me, I didn’t want this tiny house, but it was the only one I could afford.”

곧 할 말을 강조할 때 사용하기도 합니다.

Believe me, this is the cheapest, tiniest house ever!”

12. I guess/I suppose

“I guess”와 “I suppose”는 당신이 무언가를 말하기 망설이고 있거나 확인이 잘 안 설 때 붙이는 말입니다.

“I was going to eat dinner at home, but I guess I can go eat at a restaurant instead.”

“I guess”는 구어체로 많이 쓰이지만 “I suppose”는 조금 더 예스러운 표현처럼 들릴 수도 있습니다 (조금 더 배운 사람 같은 표현이랄까요).

13. Or something

“Or something”은 문장 맨 끝에 붙이며, 정확한 정보를 모를 때 쓸 수 있습니다.

“The cake uses two sticks of butter and ten eggs, or something like that.”

14. Okay/so

“Okay”와 “so”는 주로 말 첫머리에 쓰며 새로운 주제로 넘어간다는 표시로 쓰입니다.

So what are you doing next weekend?”

여태까지의 일을 요약할 때 말 첫머리에 쓰기도 하죠.

Okay, so we’re going to need to buy supplies for our trip this weekend.”

15. Right/mhm/uh huh

“Right”, “mhm”, “uh huh”는 긍정을 뜻하는 대답처럼 쓰입니다. 한마디로, “yes”를 의미하죠.

Right, so let’s prepare a list of all the things we’ll need.”

Uh huh, that’s exactly what he told me too.”

좋아요. 여기까지 배우셨으니 이제 여러분은 영어 추임새의 전문가가 다 되셨을 겁니다! 오늘 배운 단어들은 영어 추임새인 만큼, 특히 의미가 오묘하고 문맥에 따라 달라지는 경우가 많아 정확한 용법으로 쓰기 어려울 수 있습니다. 하지만 영어 추임새의 용법을 제대로 마스터하면 머지않아 영어 원어민이 말하는 것 유창한 영어를 구사할 수 있게 될 것입니다.

728x90

'English > OPIC' 카테고리의 다른 글

오픽노잼 정리  (0) 2021.09.09
오픽 위기 탈출  (0) 2021.09.08
OPIC_해커스인강_09_해변가기  (0) 2021.08.16
OPIC 학습 계획  (0) 2021.08.15
OPIC_해커스인강_07_공연,콘서트 관람  (0) 2021.08.15
728x90

728x90
728x90

728x90
728x90

문제

- (0,0) 부터 시작해서 아래 or 아래우측으로 이동 가능

- 만나는 수자는 모두 더함

- 더한 숫자가 최대가 되는 경로는? 

- 더한 숫자의 최대 합은?

 

 

728x90
728x90

728x90
728x90

728x90
728x90

5C2 = 5! / 2!(5-2)! = 120 / 2 * 6  = 10

 

5C2 = 4C2 + 4C1 

728x90

'수학과물리' 카테고리의 다른 글

Log  (0) 2021.08.13
Bezier Curve  (0) 2020.03.12
728x90

하나의 시작점으로 구성된 트리에 간선을 하나씩 수집하여 진행

- 다익스트라는 시작점을 기준으로 cost 계산

- 프림은 트리의 정점집합을 기준으로 cost 계산

728x90
728x90

스패팅트리

 

최소스패닝트리(MST)

크루스칼(Kruskal) 알고리즘

 

크루스칼,Kruskal,MST

- 탐욕적인(greedy) 방법을 이용 - 지금 이 순간에 최적인 답을 선택하여 결과를 도출하자 - 순환이 안 생기도록 주의 - 연결된 정점이 속한 그룹 단위로 관리. 그룹과 그룹이 연결되면 하나의 그룹

mangpeng.tistory.com

 

PPT

 

728x90
728x90

- 탐욕적인(greedy) 방법과 Disjoint Set을 이용하여 MST(Minimum Spanning Tree)를 구한다.

 

구현 방법 Steps

1. 최소 코스트 경로를 임의로 선택

2. DisjointSet을 이용하여 해당 경로가 사이클이 발생 했는지 체크

3. 다음 최소 코스트 경로를 기준으로 step 반복

 

 

제시된 상황

1. 최소 경로 중 임의 경로 선택

2. 선택된 경로 중 싸이클이 발생 했는지 확인

3. DisjointSet을 이용하여 경로 채택 여부 판단

Result

PPT

728x90
728x90

DisjointSet(상호배타적집합, 서로소 집합)

- 서로 공통된 원소를 가지고 있지 않은 두개 이상의 집합을 말한다.

- DisjointSet data Structure를 사용하면 서로 다른 원소들이 어떤 집합에 속해 있는지를 판단하기에 유용하다.

- 정의에 의해 Disjoint Set 사이에는 교집합이 없기 때문에, 합 연산을 하는 과정에서 두 집합 사이의 겹치는 원소를 특별히 고려하지 않고 모든 원소들을 하나의 집합으로 합치는 것이 가능하다. 이 합하는 과정과 각 원소들이 어떤 집합 속에 있는지 판별하는 과정을 효율적으로 찾기 해서 Disjoint Set Union을 사용합니다.

 

 

DisjointSet은 트리를 이용하여 표현할 수 있습니다.

벡터를 이용한 DisjointSet 트리 구조 표현

 

Union 합치기

 

일반적으로 아래와 같이 합치기 연산을 진행  했을 때는 O(N) 시간 복잡도를 갖게 됩니다.

void Merge(int u, int v)
{
	u = Find(u);
	v = Find(v);

	if (u == v) 
		return;
	
    _parent[u] = v;
}

 

랭크압축(Rank Compression) 통한 최적화

    void Merge(int u, int v)
    {
        u = Find(u);
        v = Find(v);

        if (u == v) // 대장이 같은지 체크
            return;

        if (_rank[u] > _rank[v])
            ::swap(u, v);

        _parent[u] = v;

        if (_rank[u] == _rank[v])
            _rank[v]++;  
    }

Find 찾기

 

일반적으로 아래와 같이 소속을 찾는 함수를 구현하게 되면 Find 함수가 호출될 때마다 재귀가 호출되므로 비효율 적입니다

    int Find(int u)
    {
        if (u == _parent[u])
        {
            return u;
        }

        return Find(_parent[u]);
    }

 

경로압축(Path Compression)을 통한 최적화

 

아래와 같이 소속을 찾는 함수가 호출하게 되면 u의 parent를 root parent로 바꿔주는 경로압축을 통해 이후에 호출되는 Find(u) 함수는 빠르게 탐색이 가능하게 됩니다.

    int Find(int u)
    {
        if (u == _parent[u])
        {
            return u;
        }
        
        return _parent[u] = Find(_parent[u]);
    }

경로압축

 

Conclusion

- 소속을 합치고, 요소의 해당 소속을 찾는데 적합한 자료구조

- 시간 복잡도 : O(Ackermann(n)) = O(1)

 

PPT

 

728x90
728x90

버블정렬

1.특징을 아는대로 쓰시오

-

-

-

2.원리에 대해 간단하게 구두 혹은 그림으로 설명하세요

-

3.시간복잡도 

-

 

선택정렬

1.특징을 아는대로 쓰시오

-

-

-

2.원리에 대해 간단하게 구두 혹은 그림으로 설명하세요

-

3.시간복잡도 

-

 

삽입정렬

1.특징을 아는대로 쓰시오

-

-

-

2.원리에 대해 간단하게 구두 혹은 그림으로 설명하세요

-

3.시간복잡도 

-

 

힙정렬

1.특징을 아는대로 쓰시오

-

-

-

2.원리에 대해 간단하게 구두 혹은 그림으로 설명하세요

-

3.시간복잡도 

-

 

병합정렬

1.특징을 아는대로 쓰시오

-

-

-

2.원리에 대해 간단하게 구두 혹은 그림으로 설명하세요

-

3.시간복잡도 

-

 

퀵정렬

1.특징을 아는대로 쓰시오

-

-

-

2.원리에 대해 간단하게 구두 혹은 그림으로 설명하세요

-

3.시간복잡도 

-

 

구현해보기

c++

728x90
728x90

map vs hash_map

map

 

hasp_map

 

C# dictionary는 무엇일까?

-

728x90
728x90

정의

-

-

 

시간 복잡도

- 삽입 : 

- 삭제 : 

- 검색 : 

 

 

삽입/삭제시 일어나는 flow에 대해서 간략히 설명하시오.

-

-

728x90
728x90

map vs hash_map

map

- stl container map은 균형 이진 트리인 레드 블랙트리로 이루어져 있다.

- 삽입/삭제/검색 시간 복잡도는 O(logN)이다.

 

hasp_map

- c++11 표준 기준으로 unorder_map이다.

- 삽입/삭제/검색 시간 복잡도는 O(1)이다

- 해시값일 이용해서 데이터를 관리한다. 때문에 많은 메모리를 사용하고 대신에 속도가 빠르다.

- 해쉬값을 관리하는 방법에는 선형 조사법(inear probing), 이차 조사법(quadramic probing), 체이닝 등이 있다.

 

C# dictionary는 무엇일까?

c# dictionary = c++ map (x)

c# dictionary = hash_map(c++ unordered_map)

 

 

728x90
728x90

버블정렬

- 배열의 앞뒤 요소를 비교해가면서 가장 큰 값을 배열의 맨뒤로 보내는 방식

- O(n^2)

 

선택정렬

- 배열을 순회 하면서 가장 찾은 값을 찾아서 맨 앞에 위치와 바꾸는 방색

- 버블 정렬과 달리 매번 값을 바꾸는게 아닌 가장 찾은 값 인덱스를 찾고 한번만 swap이 일어난다.

- O(n^2)

 

삽입정렬

- 새로운 배열에 선택된 값을 정렬된 위치에 넣는 방식으로 정렬이된다.

- 기존에 데이터가 정렬된 상태라면 조금 더 유리하다.

- O(n^)

 

- 힙트리를 이용한 정렬

- O(NlogN)

 

병합

- 분할, 정복, 결합

- 개념이 중요함

- 멀티스레드에서 분할해서 정복하고 같이 결합하는 방식 등으로 활용될 수도 있는 개념이다.

- O(NlogN)

 

- 최악 O(N^)

- 평균 O(NlogN)

- 병합은 임시 벡터를 만들기 때문에 퀵정렬이 평균적으로 더 빠를 수 있다.

728x90
728x90

주요 인터페이스 개념

생상자에 true/false 값으로 Set/Reset 여부를 지정할 수 있음

Set : 차단기를 올린다. 차가 지나 갈수 있음. (스레드 진행)

WaitOne : 차단기가 열리기까지 기다린다. 열려 있으면 차가 지나가고 아니라면 기다린다.

Reset : 차단기를 내린다. 이후 차는 다시 차단기가 올라가기(Set)까지 지나 갈 수 없다.

 

ManualResetEvent Vs AutoResetEvent

AutoResetEvent는 WaitOne 호출되고 바로 Reset 호출된다

반면, ManulResetEvent는 WaitOne 이후에 명시적으로 Reset을 호출해야 한다.

 

테스트 코드

 class Program
    {
        static ManualResetEvent event1 = new ManualResetEvent(true);

        static void Main(string[] args)
        {

            Timer timer = new Timer();

            timer.Interval = 1000;
            timer.Elapsed += Timer_Elapsed;
            timer.Start();

            while(true)
            {

            }
        }

        private static void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            event1.WaitOne();
            event1.Reset();

            //Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
            DateTime now = DateTime.Now;

            Random ran = new Random();
            Thread.Sleep(ran.Next(0, 10000));

            Console.WriteLine(now);

            event1.Set();
        }
    }

 

728x90

+ Recent posts