이것저것

미국 천연가스 Upstream & Downstream 기업

꼬북칩조아 — Mon, 8 May 2023 07:13:13 +0900

Upstream 기업

1. Exxon Mobil Corporation (XOM)

2. Chevron Corporation (CVX)

3. ConocoPhillips Company (COP)

4. EOG Resources, Inc. (EOG)

5. Pioneer Natural Resources Company (PXD)

6. Occidental Petroleum Corporation (OXY)

7. Devon Energy Corporation (DVN)

8. Continental Resources, Inc. (CLR)

9. Marathon Oil Corporation (MRO)

10. Apache Corporation (APA)

11. Cabot Oil & Gas Corporation (COG)
12. EQT Corporation (EQT)
13. Antero Resources Corporation (AR)
14. Range Resources Corporation (RRC)
15. Southwestern Energy Company (SWN)
16. Chesapeake Energy Corporation (CHK)
17. Diamondback Energy, Inc. (FANG)
18. Noble Energy, Inc. (NBL)
19. Newfield Exploration Company (NFX)
20. Murphy Oil Corporation (MUR)
21. Cimarex Energy Co. (XEC)

midstream 기업

1. Kinder Morgan, Inc. (KMI)
2. Enterprise Products Partners L.P. (EPD)
3. Energy Transfer LP (ET)
4. Williams Companies, Inc. (WMB)
5. ONEOK, Inc. (OKE)
6. MPLX LP (MPLX)
7. Cheniere Energy, Inc. (LNG)
8. Targa Resources Corp. (TRGP)
9. Magellan Midstream Partners, L.P. (MMP)
10. Western Midstream Partners, LP (WES)

11. Antero Midstream (AM) : 0.71 billion

12. Equitrans Midstream Corporation (ETRN) : 0.82 billion

13. EQT Resources, LLC (EQT)

코엔자임 Q10(코큐텐) 반드시 먹어야 하는 이유

꼬북칩조아 — Tue, 18 Apr 2023 00:24:05 +0900

오늘은 코엔자임 Q10(코큐텐) 반드시 먹어야 하는 이유에 대해 포스팅해보겠습니다.

코큐텐은 레이 커즈와일의 영양제로도 유명한데요.

레이 커즈와일은 세계적인 기업 '구글'에서 미래 기술에 대해 연구하는 학자입니다.

구글 소속 미래학자 '레이 커즈와일'의 영양제

그는 수명 관련 의학 분야 전문가인 테리 그로스만 박사와 함께 플랜을 짜고 그대로 행하고 있는데요.

하루에 영양제 수십알을 먹고, 약값만 일년에 10억 이상인 그가 가장 중요한 3가지로 뽑은 영양제들은 바로

일명 코큐텐으로 알려진 코엔자임 Q10, 포스파티딜콜린 그리고 비타민D (비타민중에서 가장 중요하다고 강조) 인데요.

오늘은 그중에서도 코큐텐(코엔자임 Q10)에 대해 알아보도록 하겠습니다

코엔자임 Q10

코엔자임 Q10은 세포의 미토콘드리아에서 에너지 생산에 중요한 역할을 하는 비타민과 비슷한 물질입니다.

최근 연구에서는 코엔자임 Q10의 다양한 생리학적 기능과 건강상의 이점에 대한 관심이 증가하고 있습니다.

최근 연구 중 하나는 코엔자임 Q10의 노화 예방 효과와 관련된 것입니다.

노화는 생물학적인 과정으로, 인체가 노화되면서 생체 기능이 저하되고, 질병 발생 가능성이 증가하게 합니다. 노화는 다양한 원인으로 발생하는데, 그 중 하나는 미토콘드리아 기능의 손상입니다. 미토콘드리아는 에너지 생산에 필수적인 역할을 담당하고 있으며, 노화 과정에서 미토콘드리아 기능이 저하되면서 세포 손상이 발생하는 것이죠.

그런데 최근 연구에서는 코엔자임 Q10이 미토콘드리아 기능을 개선시키고 노화를 예방하는 데 도움이 된다는 것이 제시되었습니다. 이 연구에서는 코엔자임 Q10 보충제가 노화에 따른 기억력 저하를 예방하는 데 효과적이라는 결과가 나왔는데요, 이 연구에서 코엔자임 Q10 보충제를 투여한 실험군과 플라보 보충제를 투여한 대조군을 비교하였으며, 코엔자임 Q10 보충제를 복용한 실험군에서는 기억력이 유지되는 것으로 나타났습니다. 또 다른 연구에서는 코엔자임 Q10이 노화 과정에서 산화 스트레스를 감소시키는 데도 도움이 된다는 것도 밝혀졌습니다. 산화 스트레스는 노화와 관련된 여러 질병의 원인이 될 수 있는데, 코엔자임 Q10은 산화 스트레스를 줄이는 항산화 효과를 가지고 있습니다. 이 연구에서는 코엔자임 Q10을 투여한 실험군에서 노화 과정에서 산화 스트레스가 감소하는 것으로 나타났습니다.

즉, 여러 연구로부터 코엔자임 Q10이 노화 과정에서 미토콘드리아 기능을 개선시키고 산화 스트레스를 줄이는 데 도움이 된다는 것이 밝혀짐으로써, 코엔자임 Q10이 노화와 관련된 질병의 예방 및 치료에 유용할 수 있다는 가능성을 제시했습니다.

또 다른 효과는 코엔자임 Q10이 심근 경색 환자에게 미치는 효과에 대한 것입니다. 최근 연구에서는 코엔자임 Q10 보충제가 심근 경색 후 심근 손상을 감소시키고 심혈관 건강을 개선시키는 데도 도움이 된다는 것이 밝혀졌습니다. 이 연구는 코엔자임 Q10이 심혈관 질환 예방과 치료에도 유용할 수 있다는 가능성을 보여줬습니다.

심근 경색은 심장 근육 조직에 산소와 영양분 공급이 일시적으로 중단되어 심근 조직이 손상되는 질환으로, 심장 근육 조직 손상으로 인해 심장 기능의 저하, 심부전, 심박동 이상 등의 증상을 유발할 수 있는데요. 앞서 언급했듯 코엔자임 Q10이 미토콘드리아 기능을 개선시키고 세포의 에너지 생산에 관여하는 기능 때문에 심근 경색 환자들에게도 관심을 받고 있습니다.
2019년에 발표된 한 연구에서는 코엔자임 Q10 보충제가 심근 경색 환자의 심장 기능을 개선하는 데 효과적이라는 결과가 나왔습니다. 이 연구에서는 코엔자임 Q10을 투여한 실험군과 플라보 보충제를 투여한 대조군을 비교하였으며, 코엔자임 Q10 보충제를 복용한 실험군에서는 심장 기능이 개선되는 것으로 나타났습니다. 2020년에 발표된 한 연구에서도 코엔자임 Q10이 심근 경색 환자의 심장 근육 조직 손상을 예방하는 데 효과적이라는 결과가 나왔습니다. 이 연구에서는 코엔자임 Q10을 투여한 실험군과 플라보 보충제를 투여한 대조군을 비교하였으며, 코엔자임 Q10 보충제를 복용한 실험군에서는 심장 근육 조직 손상이 감소하는 것으로 나타났습니다.

마지막으로, 코엔자임 Q10과 각종 질병의 관련성을 조사한 연구들도 이루어 지고 있는데요. 이 연구들에서는 코엔자임 Q10이 대사 증후군, 파킨슨병, 알츠하이머병 등 다양한 질병 예방에 효과가 있다는 것이 제시되었습니다. 그러나 이러한 연구들은 아직 실험적인 단계에 있으며, 추가적인 연구가 이뤄지고 있습니다.

제가 해외에서 구매해서 먹고 있는 코큐텐 영양제(+오메가+폴리코사놀 포함) 제품 링크를 첨부합니다:)

https://bitl.bz/Z5GAdI

유비바이오 뉴질랜드 COQ10 코큐텐 폴리코사놀 90 소프트캡슐

deg.kr

이상으로 포스팅을 마치겠습니다.

Ceramic frying fan's pros & cons

꼬북칩조아 — Mon, 17 Apr 2023 23:42:44 +0900

Pros:

Non-stick: Ceramic frying pans are known for their excellent non-stick properties, which means that food will not stick to the surface and make cleaning easier.
Even heating: Ceramic frying pans distribute heat evenly across the surface, which allows for more consistent cooking results.
Chemical-free: Ceramic frying pans are typically made without the use of harmful chemicals, such as PFOA and PTFE, which can be found in some non-stick coatings.
Aesthetically pleasing: Ceramic frying pans are available in a range of attractive colors and designs, which can add to the visual appeal of your kitchen.

Cons:

Fragility: Ceramic frying pans can be more fragile than other types of cookware, and can crack or chip if dropped or mishandled.
Price: Ceramic frying pans can be more expensive than other types of cookware, which may not fit everyone's budget.
Heat sensitivity: Some ceramic frying pans can be sensitive to rapid temperature changes, which can cause warping or cracking.
Limited cooking methods: Ceramic frying pans are typically not recommended for high-heat cooking methods, such as searing, due to their lower heat tolerance.

Overall, ceramic frying pans can be a good choice for those who are looking for a non-stick, chemical-free cookware option that distributes heat evenly. However, they may not be the best choice for everyone, depending on individual preferences and cooking needs.

그리운 성남 맘스파크 조리원 후기입니다(21년12월)

꼬북칩조아 — Thu, 13 Apr 2023 15:55:02 +0900

안녕하세요

아기 낳은지는 꽤 되었는데 이제서야 블로그에 조리원 후기를 올리게 되네요

살다보니 정신 없어 늦게 작성하느라 세세한 기억은 삭제되었지만,

여러 조리원을 선택지로 두고 고민하시는 분들께 조금이나마 도움이 되길 바랍니다

일단 저의 경우는 곽여성병원 산부인과를 다니고 있던 상태에서 조리원 후보가 총 세곳이었는데요

곽생로조리원 vs 신데렐라조리원 vs 맘스파크 였습니다

후보였던 다른 조리원들에 대해서도 간략히 말씀 드리자면 일단 제가 조리원을 선택할 당시에는

코로나가 심했던 시기라 곽생로 조리원의 경우 룸을 직접 볼 수가 없었어요

모델하우스처럼 실제 룸과 같게 꾸며둔걸 보고 결정해야 하는 상황이었습니다

제일 깔끔하고 시설이 좋아보였지만 그에 맞게 룸 가격, 마사지 가격, 모든면에서 가장 비쌌던 조리원이었어요

2주 있을건데 차라리 같은돈 쓸거면 마사지를 한번이라도 더 받는게 낫지 않나..?

싶어서 찾아본 두번째 후보지는 곽산부인과 맞은편에 있는 신데렐라 조리원 이었습니다

가성비 조리원으로 소문이 난 곳이었는데, 사실 시설 자체는 좀 오래되었고 룸도 곽생로에 비해서

컨디션이 많이 좋지는 않았었어요. 하지만 잠시 방문상담을 했을때 이야기 나눈 원장님과

선생님들이 너무 친절하셨던게 인상적이었습니다.

그 느낌이 너무 좋아 신데렐라 조리원으로 예약을 해두었다가, 비슷하게 출산을 한 친구가

적극적으로 맘스파크를 추천하기에 아님 말지 뭐 마음으로 상담을 하러 갔었어요

그런데 웬걸.. 곽조리원의 깔끔함과 신데렐라의 가성비를 합쳐둔 느낌이랄까요?

곽 만큼 룸 컨디션도 좋고 시설이 깔끔해 보이는데 가격은 신데렐라 만큼 합리적이었어요

안되겠다 여기로 바꿔야겠다 하여 그날로 조리원 예약을 변경하였습니다

외부 시설 사진입니다

1층과 2층으로 나뉘어져 있어 엘리베이터를 타고 이동해야해요~

제가 머물었던 계절은 겨울이라 이동시에 조금 추웠던 기억은 있네요

1년도 더 지난 과거여서 사진이 많이 없지만, 1층 로비쪽에 물침대 마사지기(?)가 있구요

마사지샵 있는쪽에서 족욕도 가능합니다

2층에도 건식반신욕기랑 여러 마사지 기구들이 있는데 왜 저에게 남아있는 사진이 없을까요?ㅠㅠ

참 깔끔하게 잘 되어있는데 올리지 못하여 아쉽네요

룸 별로 상 중 하 의 가격대 룸이 있었는데, 가장 비싸고 좋은 방은 안마의자가 설치되어 있다고 해요

중간 가격의 룸에는 안마의자는 없지만 크기나 시설이 똑같아서 저는 중간 가격대의 룸을 선택하였습니다

침대가 넓어 남편과 같이 자도 불편하지 않고, 창문이 커서 외부와 단절된 시간이 조금 덜 답답하게 느껴졌어요

아직도 기억에 남고 가장 좋았던 추억은 바로 밥의 맛있음입니다...

저는 임신기간 내내 입덧의 연장선인건지 딱히 맛있는 음식도 없고 식욕 자체가 별로 없었어요

출산하고 나서도 식욕이 거의 없었는데 조리원의 밥 만큼은 너무 맛있어서 남김없이 먹었었어요

제가 조리원에있던 당시에는 코로나때문에 각자 룸에서 식사를 하고,

입소 첫날에만 식당에서 밥을 먹었었는데 딱 첫입을 먹고 남편과 너무 맛있다...!!! 하며 눈을 마주쳤었어요

간식 사진은 많이 찍지는 못했지만 오전 오후 간식으로 나뉘어져 나오는데 꽤나 알차게 나왔습니다

왜 조리원 천국이라고 하는지 알겠더라구요 둘째를 낳을 생각은 없는데.. 만약에라도 낳는다면

다시 맘스파크 조리원에 가서 저 밥을 먹고싶어요 ㅠㅠ

한가지 단점은 손목이 약해진 산모가 들기에는 식기구들이 꽤나 무거워요;;

남편이 중간에 먼저 퇴소하는 바람에 제가 직접 밖에 있는 카트까지 그릇을 들고 나갔어야 했는데

순간적으로 손에 힘이 빠져서 모든 접시를 깼던 기억이 있네요 ^^;;

그런데 인상깊었던것은 당황하며 사장님께 말씀드리자 (원장님, 사장님 각각 계세요)

너무나 당연하게 저를 먼저 걱정해주시며 괜찮냐고 1층에서 마사지 받고 있으면 치워두겠다고 하시더라구요

죄송한 맘에 마사지 한번 받고 올라가보니 여사님과 청소중이였는데 제가 너무 미안해 하는게 느껴졌는지

농담 해주시며 괜찮다고 말씀주셔서 참 감사했었어요

그 외에도 마사지사 선생님이 세분 계시는데 모두 너무 친절하시고, 실력도 훌륭하셔서 그런지

임신 10개월간 쪘던 10kg을 조리원에 있던 2주만에 모두 감량하고 나왔습니다 ^^

가슴 마사지를 매일 무료로 해주시는데 그거 덕분에 가슴이 뭉치지 않아 아프지도 않았었네요

아기를 키우던 초창기에는 육아하며 개고생할때 이 조리원이 참 많이 그리웠었어요 ㅎㅎ

마음의 고향같은 느낌이랄까 ㅠ

지인들이 아기를 낳는다면 꼭 추천하고 싶은 조리원입니다

고민하고 계신 분들이 있다면 선택하셔도 후회하지 않으실것같아요~

등센서 있는 아가, 언제까지 안고 재울수 없잖아요(마미품vs라라스배게 리뷰)

꼬북칩조아 — Thu, 13 Apr 2023 15:08:18 +0900

안녕하세요

아기 키우고 살다보니 블로그고 뭐고 일단 제가 살고 봐야겠더라구요

그래서 한참동안 글을 못올리다가 어린이집 찬스를 쓰게되어 다시 글을 올려보려 합니다

오늘 올리고자 하는 글은 마미품 vs 라라스배게 비교 리뷰에요

각각 제품 링크는 글 마지막에 첨부하겠습니다

사진 클릭하셔도 링크 확인하실 수 있습니다:)

작년에 사용했던 제품들이라 사진은 많이 없지만 저에게 고마웠던 제품들이라 또렷히 기억나는 것들을 적어보려구요

조금 긴 서론을 먼저 적어보자면..

저는 신생아 시기때는 아기가 잠들면 침대에서 재웠던 것 같은데, 육아하다 정신차려 보니 어느순간 부터는

제가 아기의 모든 낮잠을 제 품에서 안아 재우고 있더라구요?

그걸 깨닳은게 아기 50일쯤이었는데, 이게 맞나? 싶어 주변 친구들에게 물어보니 다들 잘때는 눕혀 재운다며

가뜩이나 몸도 아픈데 어떻게 잘때마다 매번 안고 재우냐고 지금부터라도 눕혀 재우는 습관을 들이라고 하더라구요

하지만 이미 제 아기는 디지털 세대에 맞는 최첨단 등센서를 가지게 된 후였고..

제가 아무리 살살 눕히고 별짓을 다해도 제 품에서 떨어져 침대에 등이 닿는 순간 울어버리더라구요

어쩌지? 하며 여러 용품을 찾아보다가 가장 먼저 시도했던게 라라스배게 입니다

라라스배게 사용 후기

왼쪽

오른쪽

배게 사용 당시에는.. 블로그고 나발이고 살벌한 육아 현장에서

당장 오늘과 내일의 생존이 목표였던 시기라, 이런 리뷰를 쓸 줄 모르고 사진을 많이 안찍어 두었네요

오랜만에 보는 아기의 더 어렸던 시절 사진을 보니 너무 귀엽네요..^^

라라스 배게는 옆으로 재우는 배게로 유명한 배게인데요

저의 경우는 안아서 재우고 눕히는것이 아닌, 저 배게 구입 후 아싸리 저렇게 옆으로 눕힌 상태에서

쉬닥법으로 토닥이며 아기를 재웠었어요

아기 배게 치고 비싼 가격에.. 효과를 못보면 어떡하나 걱정을 좀 했었는데,

저는 이 배게에서 아기를 재우고 엄마가 된 뒤 처음으로.. 아기 낮잠 시간에 밥도 먹고 커피도 마실수 있었어요

그 전에도 눕혀서 재워보려 많은 시도를 했지만 울면서 아예 자지 않거나 겨우 잠들었어도

30분만에 기상했던 아기였는데, 정말 놀랍게 이 배게를 쓴 뒤로 1시간 30분씩 꿀잠을 자더라구요!!

제가 사용했던 당시에는 매쉬 커버가 출시되지 않았어서, 유일한 단점은 솜 때문에 아기가 덥다는 거였는데..

여름을 제외한 봄,가을,겨울에는 정말 요긴하게 쓸수있는 배게라고 생각되었어요

봄에 처음 구매하여 사용하다가 여름이 되며 아기 배쪽에 땀띠가 나길래 사용을 중단하게 되었지만

엄마인 저에게 첫 휴식을 선물해준 은인간은 배게입니다

오랜만에 블로그를 쓰기도 하고, 정보를 드리기에는 사진도 별로 없고 세세한 기억이 삭제되었지만

정말 추천하고 싶은 배게입니다! 비싼 가격에 구매를 망설이실수 있지만 저는 일단 후회하지 않았어요~

(광고 아닙니당 저에게 광고를 주지도 않아요 ㅎㅎ!!)

너무 두서없이 적은것같으니 제가 느낀 장단점을 한번 더 요약하자면..

<장점>

1.등센서 있는 아기에게 최적화된 옆으로 자는 배게

2. 저 배게를 사용한뒤로 낮잠 시간이 안정적으로 확 늘었었어요

<단점>

1.솜 커버로 인한 땀띠주의, 그리고 더울때 사용하면 아기도 짜증내며 못자는듯 했습니다

(지금은 매쉬커버 출시되어 보완된 단점이긴 합니다)

2.어린 아기의 몸을 배게로 고정한것이다 보니 약간의 위험성은 있어보여요

저는 혹시 몰라 배게 머릿쪽 솜은 모두 빼고 틈틈이 아기가 잘 자는지 확인했었어요

등센서 있는 아기의 첫 배게로 꼭 추천하고 싶은 배게입니다

마미품 배게 사용후기

육아 현장에서 한줄기 빛이었던 라라스배게의 치명적인 단점이었던 솜 커버때문에

여름에는 사용을 할 수가 없었어요. 그래서 어찌 낮잠을 재우나 고민하던차에 발견한 마미품 배게입니다

사실 마미품은 정면으로 재우는 용도로도 많이 쓰실텐데, 저의 경우는 아기가 이미 옆으로 자는것에

익숙해졌던 상태여서.. 정면으로 재우게 되니 또 자주 깨며 낮잠을 제대로 자지 못하더라구요

해서 제 나름의 머리를 써서 비주비노 침대 위에 마미품을 깔고, 친정에서 훔쳐온 좁쌀배게를 등 뒤에 받쳐주어

옆으로 재우게 되었어요! 여름버젼 짭 라라스배게라고 해야하나...

제 열렬한 첫사랑이 라라스배게라면, 마미품은 뜨겁지는 않지만 은은하게 날 편안하게 해주는 남자친구 느낌이랄까요..?

사계절 내내 사용이 가능한 배게이다 보니 아기 돌 가까워 질때까지 오래 사용할수 있더라구요

더 어릴때는 저렇게해서 옆으로만 재우다가 어느 순간부터는 정면으로도 잠을 잘 자기에

정면으로 잘 때에도 잘 사용할수 있었습니다

허접하고 장황한 글을 다시 요약해보자면..

<장점>

1.사계절 내내 사용 가능

2.정면으로도 잘 수 있고, 조금 더 아이템을 우겨넣으면 옆으로도 재울수있음

<단점>

1.등센서가 심한 아기에게 엄마의 품 처럼 편안하게 느껴질 배게는 아닌것같음(개인적 생각)

2.팔쪽에 좁쌀을 넣고 사용하는 배게인데, 아기가 조금 더 크면 힘이 쎄져서 어떤날은 팔에 있는 좁쌀을 스스로 치우다

그게 목쪽에 가있기도 하고 아기 가슴을 너무 짓누르기도 하더라구요

(팔쪽을 모아서 사용할수도 있는데 저희 아기는 그걸 싫어했었어요)

두 제품 다 엄마를 위해, 아기를 위해 너무나 잘 만들어진 제품이라는 생각이 들지만

굳이 굳이 무엇을 먼저 살까? 어떤걸 더 우선시 구매할까? 라고 물어보신다면

제 대답은 라라스 배게입니다~ 아쉽게도 매쉬 커버를 사용해보진 못했지만 제가 느꼈던

유일한 단점이 보완이 되었으니 앞으로 사용하실 분들에게는 더 좋은점이 많을것같아요!

두 제품 후기를 줄줄이 적어보았는데요

제가 봐도 노잼이라 도움이 될지는 모르겠지만 ^^;;

제 후기를 보고 조금이라도 지친 육아에서 약간의 휴식을 얻을수있는 제품을 구매하실수 있으면 좋겠습니당

이상으로 이번 포스팅을 마칩니다 :-)

https://bitl.bz/rocZR5

베베데코 프리미엄 마미품 유아동 베개 코코 그레이

deg.kr

https://bitl.bz/b9kYsg

라라스 베개

deg.kr

Article: ChatGPT Helps Man Launch Business in 24 Hours

꼬북칩조아 — Tue, 11 Apr 2023 07:46:38 +0900

ChatGPT Helps Man Launch Business in 24 Hours

Who wouldn't love to make lots of money in a short time? But the question is: "How?"
For Jackson Greathouse Fall, all it took was a conversation with ChatGPT.

On March 15, 2023, Fall tweeted that he gave GPT-4, the newest version of the artificial intelligence (AI) chatbot, a budget of $100 and one job: turn it into as much money as possible in the shortest time possible.
Fall told the chatbot — which he named "HustleGPT" — he was its "human counterpart" and would do everything it said, as long as it was legal, and didn't require him to do any physical work.
Fall was told to first buy an internet domain with a catchy name and a cheap hosting plan.
This cost him under $40.
Soon, Fall was running Green Gadget Guru, an affiliate marketing website that posts content about sustainable products.
Fall used Dall-E — another AI bot created by the same company — to make the logo, and HustleGPT created the code for the website.
Later that day, the first content was released: an article about sustainable kitchen products, written by the chatbot.
Fall also spent $40 marketing on Facebook and Instagram, as advised by HustleGPT, and by the end of the day he said he had received $500 from investors.
Three days later, Fall announced that the chatbot had allowed him to employ people to work for Green Gadget Guru.

Fall inspired others to use ChatGPT for their own business ideas — with many sharing their experiences on Twitter using the hashtag "HustleGPT."

However, Maggie Harrison, writing for Futurism, notes that the site does not seem to work well, and said it's strange that a chatbot would want to hire humans to write for it. She wonders if Green Gadget Guru is actually as successful as Fall says it is.

All it took was a converation with Chat GPT : ChatGPT 와 대화만으로 목표를 이뤘다 (의역)
affiliate marketing : 다른 회사나 웹사이트 제품을 홍보하고 이를 판매할 때 일정한 수수료를 받는 비지니스 모델
sustainable products : 지속가능한 제품
with many sharing their experiences on Twitter using the hashtag "Huslte GPT"
많은 사람들이 그들의 경험을 트위터상에 'Hustle GPT' 해시태그를 사용하여 공유했다

Discussion

What are your thoughts on Jackson Greathouse Fall's story?

I think it's worth a try.
Since GPT has been launced not so long ago, using GPT for business is considered an early market
Of course, the affiliate marketing business model may be saturated, but if i run it steadily, there is a chance of sucess. If I use GPT, it seems like it can be sustainable with minimal effort

Would you be comfortable relying on a chatbot to start your own business?

It may be difficult to say that relying on GPT for business is comfortable, but there is no other way for me to minimize my time and costs except for this method. Therefore, even if it fails, I think it is a low-risk way.

Have you tried out ChatGPT or Dall-E? If so, how did you find them?

I have never heard of 'Dall-E' but I am aware of(familiar with) 'ChatGPT' and I use it quite often.
The first time I learned about it was when a YouTube streamer introduced it.
I use it a lot especially for my work and studying english

What impact do you expect AI to have on businesses in the near future?

It seems that people's work styles will change
Specailly, instead of obtaining information through keyword-based Google searches, people will switch to searching by asking questions in a raw foramt to GPT.
In addition, it appears that with the help of AI, tasks such as summarizing large amounts of data or access materials in other languages will become much easier.

Are you excited or worried about the future of AI?

I feel like it's a mixed bag
On one hand, I expect that with the help of AI, many innovations that human have been unable to achieve so far will become possible.
On the other hand, I am also concerned that AI could replace many jobs in various industries

Further Discussion

Do you know anyone who runs their own company?

Have you ever thought about starting your own business?

What do you imagine are the hardest things about building a business?

If you could get business advice from anyone in the world, who would it be?

Some people dream of success, while other people get up every morning and make it happen. — Wayne Huizenga. What are your thoughts on this statement?

~에 무리(부담)가/이 갈거야 영어로 + 자주 쓰는 표현 5개

꼬북칩조아 — Tue, 11 Apr 2023 06:40:39 +0900

be hard on (someone/something) : ~ 에 무리(부담)가 /이 갈거야

오랜시간동안 컴퓨터를 사용하면, 눈에 무리가 갈수 있어

If you use computers for long periods of time, it can be (really) hard on your eyes (It's not good for your eyes)

나는 스스로에게 부담을 주는 경향이 있어, 그게 항상 날 긴장하게 하지

I tend to be too hard on myself, which always makes me nervous

(자책을 심하게 하고 있는 사람에게) 너무 그러지마라

Don't be too hard on yourself

그동안 무릎에 무리가 많이 갔다

It's been really hard on my knees

아냐 그냥 일반 가방을 사. 그게 허리에 덜 부담될거야

No just get a regular bag(or back-pack). That'll be easier (less harder) on your back

영어 표현 5개 소개

오늘 제가 자주 사용하기 좋아하는 몇가지 표현들에 대해 다뤄보고 싶어요
오늘 이 표현들 전부 혹은 몇개라도 단순히 이것들을 번역하려고 할때, 한국어로는 꽤 잘 되더라도 이해(공감)하는데 약간 어려움을 느끼실 지도 몰라요 이 표현들에 대한 정확한 번역을 하려고 하는 대신, 이것들의 의미가 뭔지, 그리고 어떤 상황에서 우리가 이것들을 사용할 수 있는지에 집중하길 바래요
첫번째것 부터 시작해보죠

Today I wanna go over with you just a few expressions that I like to use quite often.
Now you might find some, if not all, of these expressions today a little difficult to relate to because when you’re simply trying to translate them, they’ll translate very well into korean. So instead of trying to find exact translations for these expressions, I want you to focus on understanding their meaning and what situations we can use them in. Alright, let’s begin with the first one.

go over : 다루다, 검토하다
some, if not all : 전부가 아니라면 몇개라도
find A + 형용사 : A 가 <어떻다> 고 느끼다 / 어떻다는 인상을 받다
relate to : (무엇)에 공감하다

You gotta start somewhere : 어디서든 시작해봐 (완벽하지 않더라도 시작하는게 중요하다)

“you gotta start somewhere.”
무슨 의미인가요?
여러분이 베이커리를 배우기 시작했다고 해봅시다. 빵, 쿠기, 케익 만드는거요 그리고 막 첫번째 케익을 만들었다고 해보죠. 첫번째 케익을 막 끝냈어요. 그리고 당신이 만든 케익을 봅니다. 끔찍하게 생겼어요. 완전히 최악이죠. 당신은 케익을 보면서 말합니다

A: 와, 사람 죽일듯하게 생겼다 (그럼 옆사람이 말할 겁니다)
B: 괜찮아 'you gotta start somewhre'

자 이게 무슨 의미냐면 비록 잘 해내진 못했지만, 이것이 첫번째 시도였고, 배워가는 과정이죠. 아주 초반에는 누구도 잘 할 수 없
그런데 첫번째 시도 없이는 결코 배우지 못하죠. 그래서 이것이 앞으로 있을 많은 'stepping stone' 의 첫번째가 될 것이라는 거에요
그래서 그것이 이것의 의미입니다. 'you gotta start somewhere'는 시작을 해야한다라는 의미죠. 향상 하기 위한 시작점이 반드시 존재한다. 그것이 이 표현이 강조하는 것입니다.
시작이 존재하고 시작은 항상 완벽하진 못하죠. 이 표현은 당신이 이미 한 일 뿐 아니라, 막 하려고하는일에도 사용할 수 있어요. 예를 들면 당신이 누군가 운전연습을 도와준다고 해봅시다. 당신은 그사람 옆 조주석에 앉아서 운전 연습을 도와주죠

당신이 드라이버에게 얘기합니다
A: 자 이제 저 트럭 옆에 주차해
B: 잠깐만. 나 진짜 해도돼?
A: you gotta start somewhere. 괜찮아 해봐.

무슨 의미인가요? 시도해보지 않으면 시작이 없으면 절대 향상되지 않을 거다 배울수 없을거다 라는 거죠.
그래서 어디서든 시작하는 것이 중요한거에요. 그래요. 그래서 우리가 항상 어디서든 시작해야 한다는 겁니다

What does that mean?
Let’s say you just started learning bakery (how to bake) you know like baking bread, cookies and cakes and let’s say that you just baked your first cake, you’ve just finished baking your first cake. And you’re looking at your cake and it looks horrible, just absolutely terrible. Okay, and you’re looking at your cake and you say

A : Wow, this actually looks like it could kill someone (and the person next to you might say)
B : it’s ok you gotta start somewhere

Now what that means (in this situation) is that (그게 무슨 의미냐면) although you didn’t do a very good job this was only your first attempt, first trial, there’s a learning process and not everybody can do a really good job from the very beginning. But without the first attempt, you’ll never learn. So this will be the first of many stepping stones along the way. So that’s what this means. You gotta start somewhere means you have to have a beginning. There must be a beginning in order to improve okay? That’s what this expression emphasizes on. There has to be a beginning and the beginning is not always perfect. Now this expression is not only for something you’ve already done but we also use this expression for things that we’re about to do, so for example, let’s say that you’re helping someone practice their driving skills. Okay so you’re sitting next to them “in" the passenger seat and you’re helping them practice driving.

You tell driver
A : OK, now, park next to that truck (and driver says)
B: Wait, are you sure I’m ready for that? (and you might say)
A : you gotta start somewhere. It’s ok, try it

What does that means? It means unless you try it, unless there’s a beginning you’ll never improve, you’ll never learn, so It’s important that you start somewhere, okay, that’s why we say you gotta start somewhere.

Let's say : ~ 라고 가정해보자
What that means is that : 그게 무슨 의미냐면, ~
without A, you'll never B: A 없이는 B를 절대로 할 수 없을거다
This will be the first of many A along the way: 이게 앞으로 있을 많은 A 중 첫번째가 될 것이다

There's only one way to find out : 해보는 수밖에 없지, 해보면 알겠지

Alright let’s move on to the next one, um.. the next expression I want to show you today is “there’s only one way to find out.” I personally love this expression, because it’s emphasizing the importance of action rather than just talking about something. And just worrying about what could be or what could not be. Let’s imagine a very simple situation. Two guys are trying to figure out what to do for lunch and one guy asks the other

A : have you been to that taco place across the street? (and the guy says)
B : no, I haven’t
A : Hmm, I wonder if they’re any good (that means you know you’re wondering if they make good tacos) (and the other guy might say)
B : There’s only one way to find out

So what does that mean? What is that the one way. To actually try it. The only way to find out whether that place makes good tacos or not is to actually go there and try their tacos. So this expression (that) there’s the only way to find out pretty much takes away the need to talk about something any further. It’s really kind of meaningless to talk about something because there really is only one way to be sure about something and that is to actually do it, try it.

A: Have you been to that taco place across the street ?
B: No I haven't
A: Hmm, I wonder if they're any good
B: There's only one way to find out

emphasize the importance of A : A의 중요성을 강조하다
figure out what to do for breakfast/lunch/dinner : 식사를 어떻게 할지 정하다

What's the worst that can(could) happen? (= It's worth trying) : 별일 있겠어?
What have we(you) got to lose ? : 잃을게 뭐 있어?

Alright, let’s look at the next one. the next expression I wanna show you today is “what’s the worst that can happen?”. now of course depending on the situation, this could actually be a question but in most cases this is a rhetorical question (수사학적 질문 it is a question you’re not expecting anyone to answer). It means you’re not actually looking for an answer. You’re actually making a point (주장하다, 의사 밝히다) in a question form. So when we say “what’s the worst that can happen?”. it actually means the worst that can happen actually is not bad so it’s worth trying. Okay it means something is worth trying because the worst that can happen is actually not that bad so in relation to this we can actually also think about the expression “what have we(you) got to lose?” What’s the worst that can happen? Not that much, so what have we got to lose? so therefore, it’s worth trying (it’s worth a shot) because the worst that can happen is not that bad so what have we got to lose? Alright, so maybe we can think of these three expressions together.
What’s the worst that can happen? – not that much – so what have we got to lose? – not a lot – so it’s worth trying (it’s worth a shot)

So the next time someone is worrying about bad result without even trying something. You can say “there’s one way to find out” and if the person continues to worry about it you can ask “what’s the worst that can happen?” or you can ask “what have you got to lose?”.

depending on the situation : 상황에 따라서는
in most cases: 대부분의 경우

If you must know , ... : 설명해줄 필요도 없지만 굳이 알려주자면

Alright, let’s move onto the next one. The next expression is “if you must know…” and then you say something, okay? What does that mean? We use this expression, when we feel slightly annoyed by the fact that the person’s asking for information that he/she (probably) has no business in knowing about Do you understand what that means? So for instance, let’s imagine that you’re with someone and you need to go because you have something to do A : I have to go B : What? Already? What? You got something better to do? (this means do you have something more important to do than to be here with me. Aright, so this is just a stupid example, but let’s just say that this’s what’s happening and so in this situation you feel that they really don’t know what they’re talking about but more importantly it’s none of your business. If you have to go or you had to go, you don’t need to explain yourself, right? But for some reasons let’s say that you decide to explain why you need to leave but at the same time, you wanna express that you feel a little annoyed by the fact that they’re not respecting your privacy, okay? So in this case, you can say A : well, if you must know, I have a sick mother and I have two younger siblings much younger than me. They’re still in school, and so, I need to go home and look after them. If you must know, it means you don’t have to know, it’s none of your business but if you must know, I have this this this going on in my life. Of course this is rather a dramatic example but I think it certainly helps to understand what it means and how we use it, okay?

A: I have to go
B: What? Already?

feel(be) annoyed by the fact that ... :어떤 사실에 의해 짜증나다
ask.. : 무엇을 요구하다
(관계절) : informatio that he/she has no business in knowing about
explain oneself

I'll have you know (that) ... : 너가 몰라서 그러는데, ...

The last expression is “I’ll have you know (that) …“ this is another expression just like the previous one…it’s an expression that we use as we begin to explain something. This is quite different from the previous one. We use this expression “I’ll have you know” when we begin to explain something and we’re explaining that because the other person has failed to show respect about something or someone out of ignorance and in most cases that lack of respect somehow insulted me not necessarily because it was an insult on me personally or family member or friend but it could simply be something that I have a lot of respect for ah.. for instance, maybe a singer so friends then maybe a person simply doesn’t know just how popular that singer was in his or her prime. Okay, so there was a singer and when the singer was in their prime, it’s really popular. they had many hit songs at that time and they were (had) big influences but this person doesn’t know how influential or how popular the signer was and simply because the person doesn’t know about the singer’s accomplishments. he or she is just showing no respect and that somehow on some levels is insulting you as a big fan in that case, in that kind of situation. You can say “hey, I’ll have you know that he/she was one of the top stars/singers in his/her prime. I’m giving you this information (I’m educating you on this) so you need to show more respect)” That’s pretty much what this means. It carries that nuance but of course, it’s doing that in a relatively tasteful (우아하게) manner, you’re not being rude, you’re not over-reacting. It’s just doing that in a tasteful way. okay That’s pretty much all I have for you today. I’ll see you in next vide

"Hey, I'll have you know that he/she was one

show respect: 존경심 보이다
out of ignorance : 무지로 인해 (모르고)
... not necessarily because ... : 꼭 A 때문은 아니고
an insult on A : A에 대한 모욕
be in (one's) prime : (누구 자신)의 전성기인

https://www.youtube.com/watch?v=ntxvluZCNYU&list=PLOzgfVOI8TGQ7TjYLxhCoX_3VlalggAUG&index=46

변환 생성자(conversion constructor)의 활용

꼬북칩조아 — Mon, 10 Apr 2023 07:43:25 +0900

변환 생성자(conversion constructor)란, 클래스의 객체를 다른 타입으로 자동으로 변환시켜주는 생성자를 의미합니다.
즉, 특정 클래스의 객체를 다른 클래스의 객체로 변환할 수 있도록 해주는 역할을 합니다.
변환 생성자는 다음과 같은 형태로 정의됩니다.

class TargetClass {
public:
    TargetClass(SourceClass source_object);
};

위의 코드에서 TargetClass는 변환하려는 타입이고, SourceClass는 변환할 객체의 원래 타입입니다.
이러한 변환 생성자는 해당 클래스를 대상으로 암시적으로 호출되며, 사용자가 직접 호출할 수는 없습니다.

예를 들어, 다음과 같은 Rational 클래스가 있다고 가정해보겠습니다

class Rational {
public:
    Rational(int numerator, int denominator);
};

이 클래스는 분자와 분모를 받아서 유리수(Rational number)를 생성하는 생성자입니다.

이제 이 클래스의 변환 생성자를 추가하여, Rational 객체를 double 타입으로 변환할 수 있도록 만들어 보겠습니다.

class Rational {
public:
    Rational(int numerator, int denominator);
    operator double() const {
        return static_cast<double>(numerator) / denominator;
    }
private:
    int numerator;
    int denominator;
};

위의 코드에서 operator double() 함수가 변환 생성자입니다. 이 함수는 Rational 객체를 double 타입으로 변환합니다.

즉, 다음과 같이 Rational 객체를 double로 변환하여 사용할 수 있습니다.

Rational r(3, 2);
double d = r; // Rational 객체 r을 double 타입으로 자동 변환

위와 같이 변환 생성자를 사용하면, 클래스 객체의 타입 변환을 간단하게 처리할 수 있으며, 코드의 가독성과 유지보수성을 높일 수 있습니다. 하지만, 자주 사용되는 타입 변환이 아닌 경우, 불필요한 오버헤드를 초래할 수 있으므로, 적절한 사용을 고려해야 합니다.

아래 예제에서는 Matrix 클래스를 정의하고, 두 개의 Matrix 객체를 더하는 연산을 수행합니다. 이 때, 더하기 연산자를 통해 두 개의 Matrix 객체를 더할 수 있도록 Matrix 클래스에 변환 생성자와 변환 연산자를 구현합니다.

#include <iostream>
#include <vector>

class Matrix {
public:
  Matrix(int rows, int cols) : rows_(rows), cols_(cols), data_(rows * cols) {}

  // 변환 생성자: std::vector<double>를 Matrix로 변환
  Matrix(const std::vector<double>& data, int rows, int cols) : rows_(rows), cols_(cols), data_(data) {}

  // 변환 연산자: Matrix를 std::vector<double>로 변환
  operator std::vector<double>() const {
    return data_;
  }

  // 더하기 연산자
  Matrix operator+(const Matrix& other) const {
    Matrix result(rows_, cols_);

    for (int i = 0; i < rows_ * cols_; ++i) {
      result.data_[i] = data_[i] + other.data_[i];
    }

    return result;
  }

  // 인덱싱 연산자
  double& operator()(int row, int col) {
    return data_[row * cols_ + col];
  }

  // 상수 인덱싱 연산자
  const double& operator()(int row, int col) const {
    return data_[row * cols_ + col];
  }

private:
  int rows_;
  int cols_;
  std::vector<double> data_;
};

int main() {
  // 2x2 Matrix 생성
  Matrix m1(2, 2);
  m1(0, 0) = 1.0;
  m1(0, 1) = 2.0;
  m1(1, 0) = 3.0;
  m1(1, 1) = 4.0;

  // 2x2 Matrix 생성
  Matrix m2(2, 2);
  m2(0, 0) = 5.0;
  m2(0, 1) = 6.0;
  m2(1, 0) = 7.0;
  m2(1, 1) = 8.0;

  // Matrix 더하기
  Matrix result = m1 + m2;

  // 결과 출력
  std::vector<double> data = result; // Matrix를 std::vector<double>로 변환
  std::cout << "Result:" << std::endl;
  for (int i = 0; i < data.size(); ++i) {
    std::cout << data[i] << " ";
    if ((i + 1) % 2 == 0) {
      std::cout << std::endl;
    }
  }
}

이 예제에서는 Matrix 클래스에 std::vector<double> 을 인수로 받는 변환 생성자를 추가합니다. 이 생성자는 std::vector<double>
을 Matrix 객체로 변환합니다. 또한, Matrix 객체를 std::vector<double> 로 변환하는 변환 연산자도 추가합니다. 이 변환 연산자는
Matrix 객체를 std::vector<double>으로 변환합니다. 이렇게 하면 Matrix 객체를 std::vector<double>로 변환할 수 있으며, 이는 더하기 연산의 결과를 출력하기 위해 사용됩니다.
더하기 연산자에서는 두 개의 Matrix 객체를 더한 결과를 새로운 Matrix 객체로 반환합니다. 이때 반환된 Matrix 객체는 std::vector<double>로 변환할 수 있으며, 이를 통해 결과를 출력합니다.
이 예제에서는 또한 Matrix 클래스에 인덱싱 연산자와 상수 인덱싱 연산자를 정의하여 Matrix 객체의 요소에 접근할 수 있도록 했습니다. 이처럼 변환 생성자와 변환 연산자를 사용하면, 클래스와 클래스 간의 변환을 편리하게 처리할 수 있습니다.
\하지만 이러한 기능을 남용하면 코드의 가독성을 떨어뜨릴 수 있으므로, 필요한 경우에만 사용하는 것이 좋습니다.

끝으로, 제 C++ 역량 향상에 많은 도움을 줬던 책(한권을 뽑으라고 하면 뽑는 책) 소개하며 포스팅을 마치겠습니다 :)

http://www.yes24.com/Product/Goods/117986059

전문가를 위한 C++ - YES24

더 쉽게, 더 빠르게, 더 깔끔하게!프로그래머가 알아야 할 C++와 C++20의 모든 것C++는 마스터하기 어렵기로 악명 높지만, 풍부한 기능 덕분에 게임이나 상용 소프트웨어 애플리케이션을 개발하는

www.yes24.com

C++ 컴파일러로 C 소스코드를 함께 컴파일하고자 할때 (extern C)

꼬북칩조아 — Mon, 10 Apr 2023 07:32:51 +0900

C++에서 C 파일을 컴파일 하려면, 해당 C 파일이 포함된 헤더 파일에 extern "C" 를 선언해주어야 합니다.
이렇게 하면 C++ 컴파일러는 해당 헤더 파일에 있는 함수 및 변수들을 C 스타일로 링크하게 됩니다.
만약 C 파일 자체를 컴파일 하기 위해서는, 해당 C 파일 내에도 extern "C" 를 선언해주어야 합니다.
이렇게 하면 C++ 컴파일러는 해당 C 파일을 C 스타일로 컴파일하게 됩니다.

예를 들어, 아래와 같은 C 파일과 헤더 파일이 있다고 가정해보겠습니다.

< sample.c 파일 >

#include "sample.h"

int add(int a, int b) {
    return a + b;
}

< sample.h 파일 >

#ifndef SAMPLE_H
#define SAMPLE_H

#ifdef __cplusplus
extern "C" {
#endif

int add(int a, int b);

#ifdef __cplusplus
}
#endif

#endif // SAMPLE_H

위의 예제에서 sample.h 파일에서 extern "C" 선언을 사용하여 add 함수가 C 스타일로 링크되도록 설정하였습니다.
이제 이 헤더 파일을 C++ 파일에서 include 하여 사용하면 됩니다.

#include "sample.h"

int main() {
    int result = add(1, 2);
    return 0;
}

sample.c 파일에서 extern "C"를 선언하지 않아도 되는 이유는, C 파일 자체가 C 스타일로 작성되어 있기 때문입니다.
C 파일은 C++과는 달리 *name mangling 을 하지 않으므로, extern "C" 선언이 필요하지 않습니다.
반면에, C++ 파일에서는 함수나 변수 이름 맹글링이 발생할 수 있으므로, C++ 파일에서 C 함수를 호출하거나 C 변수를 사용할 때는 extern "C" 선언을 해주어야 합니다.
따라서, C++에서 C 함수 또는 변수를 사용할 때는 해당 C 함수 또는 변수가 선언된 헤더 파일에 extern "C" 선언을 추가해주어야 합니다. 그러나 C 파일에서는 해당 선언을 할 필요가 없습니다.

name mangling 이란?

함수 및 클래스 이름과 같은 식별자(identifier)를 컴파일러가 처리하기 쉬운 내부 표현 형식으로 변환하는 과정을 말합니다.
이는 C++의 오버로딩(overloading) 및 네임스페이스(namespaces)와 같은 기능을 지원하기 위해 필요합니다.
C++ 컴파일러는 linker 가 사용하는 symbol 테이블을 생성하는데, 이 기호 테이블에는 함수와 클래스 이름 및 다른 식별자에 대한 정보가 포함됩니다. 이 정보를 사용하여 링커는 프로그램의 다른 부분에서 해당 함수 또는 클래스를 사용할 수 있습니다.
그러나 C++에서 함수 및 클래스 이름은 여러 매개변수를 가질 수 있습니다.

이를테면, add(int a, int b)와 add(double a, double b)는 동일한 이름의 함수일지라도 서로 다른 매개변수 유형을 가지므로 서로 다른 기호(symbol)로 링크되어야 합니다. 이때, 컴파일러는 이러한 함수 및 클래스 이름을 링커에서 사용할 수 있는 고유한 기호로 변환하기 위해 name mangling을 수행합니다.

즉, Name mangling은 컴파일러에 따라 다를 수 있지만, 일반적으로 함수 및 클래스 이름에 유일한 식별자를 추가하여 고유한 이름을 만듭니다. 이 식별자는 함수의 매개변수 유형 및 반환 유형과 같은 정보를 포함합니다.

예를 들어, add(int, int) 함수의 이름은 _Z3addii와 같은 형식으로 변환될 수 있습니다.

Name mangling은 일반적으로 개발자가 직접적으로 관여하지 않지만, 링커 오류를 해결하거나 디버깅하는 과정에서 체크해야 할 수도 있습니다.

걔 원래 그렇다고?, 나아진거야 예전엔 훨씬 심했어 / ~했던 때 기억나? 영어로

꼬북칩조아 — Mon, 10 Apr 2023 06:48:53 +0900

걔가 원래 그렇다고? < You mean he's always like that ?>
몇년 된거 같은데, 사실 많이 나아진거야 <It's been a few years now, but it's gotten a lot better actually>
예전에는 훨씬 심했어 <It used to be a lot worse >

A: Frank 무슨일 있어?
B: 왜?
A: 애가 항상 좀 날카로운거 같지 않아?
B: Frank 가 좀 그렇지
A: 걔가 원래 그렇다고?
B: 몇년 된거 같은데, 사실 많이 나아진 거야. 예전에는 훨씬 심했어

A: Hey, What's (up) with Frank?
B: Why?
A: Doesn't he seem a bit edgy all the time?
B: Oh. Yeah, that's Frank
A: You mean he's always like that ? (You mean he's always been like that?)
B: It's been a few years now, but it's(he's) gotten a lot better actually. It used to be a lot worse

"걔가 원래 그렇다고?"는 사람의 성향 등을 말하는 것이므로, (설계적 특성상) '정상'임을 의미하는 be supposed to 는 안됨
"It's gotten a lot better" 에서 it 은 Frank의 성향을 나타내는 대명사이고, "He's gotten a lot better"에서 he 는 Frank로 둘다 의미상 적절함

~ 했던거(때) 기억나? < Remember when ~>

A: 리모컨 왜이래?
B: 왜?
A: 방향키들 말이야. 너무 끈적해
B: 아 그거? 알아
A: 이것들 왜이런거야?
B: 무슨말이야? 그것들 그런지 좀 됐어
A: 아냐 그러진 않았어. 어제만해도 이러진 않았어
B: 아냐 그랬어. Kyle 이 소다 쏟은거 기억나?
A: 아니
B: 그랬었어. 그게 몇달 전이었고, 그때이후로 쭉 그래

A: What happend to the Remote?
B: Why?
A: The arrow keys. They're so sticky
B: Oh that? Yeah. I know
A: Why are they like this?
B: What do you mean? They've been like that for a while now
A: No, they haven't. They weren't like this yesterday
B: Yes. they were. Remember when Kyle spilled soda on it?
A: No
B: Well he did, that was a few months ago and it's been like that ever since

The arrow keys ----> "They are" so sticky, Why "are they" like this?, "They've been like that ~"
Oh that? 에서 that은 key가 sticky한 현상(문제)을 지칭
Yes. they were : 부정문에 대해 부정하는 대답

생각이 나다 , 생각이 들다 , 생각해내다 영어로 + <영어식 표현: get to, give a better idea>

꼬북칩조아 — Thu, 6 Apr 2023 07:40:02 +0900

정확히 생각은 안나 (정확히 기억나진 않아) 
~ 하려고 생각했어 
딱히 생각나는데가 없어 :

A: 너 혹시 거기 이름 생각나? 지난달에 Kim이랑 갔던 그 식당
B: 아 그 시푸드 레스토랑?! 딥 블루 뭐뭐 였는데 정확히 생각은 안나. 왜? 또 가고싶어?
A: 다음 달에 우리 아버지 환갑이라 좋은 데로 가야겠다는 생각이 들었는데, 딱히 생각나는데가 없어서..
너 혹시 갈만한 데 알아?
B: 응 생각나는데가 몇군데는 있어

A: Do you (happen to/by any chance) remember the name of that place ?
(Do you remember what that place was called ?)
The restaurant that we went to last month with Kim
B: Oh you mean that sea food restaurant ?! I think It was "deep blue someting"
but I don't(can't) remember exactly. Why? Do you wanna go there again ?
A: My dad's 60th birthday is next month. So I figured I should take him to a nice place.
But I couldn't really think of anywhere(anyplace). Do you know some place nice ? (Any recommendations?)
B: Yeah. I can think of a few(several) places

the name of that place : 식당 이름
the title of that movie(book) : 영화(책) 제목
혹시 : "happen to" , "by any chance"
"be called" : Do you remember what that place was called?
figure : solution 에 대한 생각 (I figured + I should ~ : ~ 해야겠다는 생각이 들었다 )
"생각이 들다" 의 다른 표현 : "It occured to me .. " , "It got me thinking"
think of 와 come up with 는 거의 유사하나, come up with 는 좀 더 창의적인 아이디어가 떠올랐을 때 주로 사용함
ex) He came up with a really great idea
really : 문맥상 "딱히"

get to

전 누구나 꿈을 갖게 된다고 생각하지 않아요 (전 누구나 꿈을 가질 순 없다고 생각해요)

I don't think everybody gets to have a dream

A: (출장 다녀온 사람에게) "관광도 좀 했어?
B: 시간이 없어서 아쉽게도 관광은 못했어

A: Did you get to do some sightseeing?
B: I didn't have time, so I didn't get to do any sightseeing

공부할 게 많아서 20대 때에는 별로 놀지 못했다

I didn't get to have much fun in my 20's because I had so much studying to do

코로나 때문에 대학 출제를 즐기지 못했다

I didn't get to enjoy the university festivals because of covid

내가 결혼할 때 아내와 나는 가난했기 때문에 멋진 허니문을 못갔다

When I got married, my wife and I didn't get to go on a fancy honeymoon because we were so poor

모든 사람이 소울메이트를 만나는 건 아니다

Not everybody gets to meet their soulmate

부정형에 some은 어울리지 않음 대신, "much" 나 "any" 사용
get to를 추가함으로써 '그부분이 아쉬웠다' 라는 뉘앙스를 추가

give someone a better understanding of
give someone deeper insight into
give someone an idea of

그걸 보니까 당시에 상황이 얼마나 심각했는지 더 잘 알 것 같더라

That(It) gave me a (much) better understanding of how serious things were back then

그걸 보니까 일반적인 연쇄살인마가 어떤식으로 형성되는 건지 더 깊이 있게 알게 됐다

This certainly gave me much deeper insight into how a typical serial killer is formed

당시에 제가 살던 집 구조를 좀 알 수 있게 그림을 대충 그려볼게요

To give you an idea of what my house looked like at the time, let me do a quick drawing
(Let me do a quick drawing here just to give you an idea of what my house looked like at the time)

어떻게 생겼었는지에 대한 대략적인 감 - the idea

"The important things is you know what this means
you don't have to necessarily have a perfect translation of this sentence as long as you understand what it means"

"I just wanted to give you an example with much more context"

"The reason I came up with a situation like this is in order to give you a better idea of when and how this expression is used.. and you know.. potentially how you might use it.. in a some situation that you might be in"

A: 다음주부터 Brenda가 널 좀 따라다니도록 할 생각이야
다 설명할 필욘 없고, 니가 하는걸 그녀가 지켜보게만 해
그렇게 하면 우리가 여기서 어떻게 일하는지 직관적으로 이해하게 될거같아
그렇게 하면 더 빨리 배울거라고 생각해. 어떻게 생각해
B: 그런다고(그렇게 한다고 해서) 크게 달라지진 않을 거야.
그러면 더 지체만 돼
그래봤자 괜히 일만 더 복잡해져

A: I'm thinking of having Brenda follow you around for the next week or so
You don't have to explain everything. Just let her watch what you do
I think that'll give her a much more intuitive understanding of how we work around here.
I think she'll learn faster that way. What do you think?
B: That wont' make a big difference (make much of a difference)
That'll only slow things down (That'll only delay the process)
That'll only complicate things (That'll only make things complicated)

"follow you around": 누군가가 다른 사람의 움직임을 따라가서 그들과 함께 시간을 보내는 것을 의미
"for the next week or so": 앞으로 약 일주일 정도의 시간 동안을 의미
"That'll only make things complicated" 보단 "that'll only complicate things" 를 더 많이씀
ex) 괜히 일 복잡하게 하지마 : Don't complicate things

Firmware(펌웨어)와 elf, bin, hex 파일

꼬북칩조아 — Tue, 4 Apr 2023 20:19:05 +0900

펌웨어(Firmware)

펌웨어(Firmware)는 하드웨어 기반 시스템에 내장된 소프트웨어입니다. 이는 기기가 동작하는 데 필요한 제어 코드를 포함하고 있으며, 하드웨어와 소프트웨어 사이에서 인터페이스 역할을 합니다.

펌웨어는 일반적으로 ROM, EPROM, EEPROM, 플래시 메모리 등의 비휘발성 메모리에 저장됩니다. 이러한 비휘발성 메모리는 전원이 꺼져도 데이터가 지워지지 않는 메모리로, 디바이스가 재시작될 때마다 펌웨어가 로드되어 기기를 동작시킵니다.

펌웨어는 하드웨어 제조사에 의해 제공되며, 장치의 제어 및 동작 방식에 영향을 미칩니다. 또한, 펌웨어 업그레이드를 통해 기기의 동작 방식을 변경하거나 버그를 수정할 수 있습니다.

일반적으로, 펌웨어는 임베디드 시스템, 컴퓨터의 마더보드, 그래픽 카드, 무선 라우터, 디지털 카메라 등과 같은 다양한 하드웨어 기반 시스템에서 사용됩니다.

펌웨어는 임베디드 장치 제조업체가 제공하는 소프트웨어 업그레이드 파일 형태로, 기존 펌웨어와 대체되어 장치의 동작 방식이 변경되는 파일입니다. 펌웨어 파일의 구조와 구성은 장치 및 제조업체에 따라 다를 수 있지만, 일반적으로 다음과 같은 구성 요소로 구성됩니다.

헤더 (Header) : 펌웨어 파일의 시작 부분에 위치하며, 파일의 버전 정보, 업그레이드 대상 장치 정보, 파일 크기 및 체크섬 등의 정보를 포함합니다. 이 정보는 펌웨어 파일의 유효성을 검증하는데 사용됩니다.

펌웨어 코드 (Firmware Code) : 펌웨어 파일의 중요한 부분으로, 업그레이드 대상 장치에 로드되어 실행되는 코드입니다. 이 코드는 기존 펌웨어와 대체되어 장치의 동작 방식이 변경됩니다.

설정 파일 (Configuration File) : 장치의 동작에 필요한 설정 정보를 포함하는 파일입니다. 이 파일은 펌웨어 업그레이드를 위해 장치에 대한 초기 설정을 제공합니다.

라이브러리 (Library) : 펌웨어 코드에서 사용되는 함수나 기능을 모아놓은 라이브러리 파일입니다. 이 파일은 펌웨어 코드를 개발할 때 재사용이 가능한 코드를 제공하며, 펌웨어 코드와 함께 업그레이드되어 장치에서 사용됩니다.

도움말 파일 (Help File) : 펌웨어 파일과 함께 제공되는 도움말 파일입니다. 이 파일은 장치에 대한 사용자 설명서, 업그레이드 방법, 문제 해결 방법 등의 정보를 제공합니다.기타 파일 : 펌웨어 파일과 함께 제공되는 기타 파일로, 펌웨어 업그레이드를 위해 필요한 파일이 포함됩니다.

펌웨어 업데이트

펌웨어 업데이트는 기존의 장치 펌웨어를 새로운 버전으로 업그레이드하는 프로세스입니다. 이 프로세스는 컴퓨터, 스마트폰, 태블릿 등 디지털 장치에서 수행됩니다. 일반적으로 펌웨어 업데이트는 다음과 같은 단계로 수행됩니다.

업데이트 파일 다운로드: 펌웨어 업데이트를 위한 새로운 파일을 다운로드합니다. 이 파일은 일반적으로 제조업체 웹사이트에서 제공됩니다.

기기 연결: 디지털 장치를 컴퓨터 또는 기타 호스트 장치에 연결합니다. 이를 위해 USB 케이블 또는 블루투스 등의 연결 방법을 사용할 수 있습니다.

업데이트 모드 진입: 기기를 업데이트 모드로 진입시킵니다. 이 단계는 장치마다 다를 수 있으며, 사용자 매뉴얼 또는 제조업체의 지침을 따라야 합니다.

펌웨어 업데이트 실행: 업데이트 파일을 장치에 업로드하고, 새로운 펌웨어를 설치합니다. 이 과정은 일반적으로 몇 분 이내에 완료됩니다.

재부팅: 펌웨어 업데이트 후에는 장치를 재부팅해야 합니다. 이를 통해 새로운 펌웨어가 적용되며, 장치가 정상적으로 작동하는지 확인할 수 있습니다.

펌웨어 업데이트는 장치의 안정성, 보안 및 성능을 향상시키는 데 중요합니다. 그러나 업데이트를 수행하기 전에는 반드시 백업을 수행해야 합니다. 또한, 업데이트 파일이 기기와 호환되는지 확인하고, 업데이트 모드에서는 다른 프로그램이나 작업을 수행하지 않도록 주의해야 합니다.

펌웨어는 보통 디버거를 사용하여 많이 하는데, 그 이유는 다음과 같습니다.

효율성: 디버거를 사용하면 펌웨어 업데이트 과정을 자동화할 수 있습니다. 이렇게 하면 업데이트 과정을 수동으로 수행하는 것보다 빠르고 효율적으로 업데이트를 수행할 수 있습니다.

오류 확인: 디버거를 사용하면 펌웨어 업데이트 과정에서 발생하는 오류를 더 쉽게 식별할 수 있습니다. 디버거를 사용하면 업데이트 중에 발생한 오류의 원인을 빠르게 찾아서 수정할 수 있습니다.

안정성: 디버거를 사용하면 펌웨어 업데이트 과정을 안정적으로 수행할 수 있습니다. 업데이트 과정 중에 오류가 발생하면, 디버거를 사용하여 업데이트를 다시 시작할 수 있으며, 이를 통해 장치의 안정성을 유지할 수 있습니다.

기능 추가: 디버거를 사용하여 펌웨어 업데이트를 수행하면, 추가적인 기능을 구현할 수 있습니다. 이를 통해 업데이트 과정을 더욱 효율적으로 수행하고, 새로운 기능을 추가하여 장치의 기능성을 향상시킬 수 있습니다.

물론 디버거를 사용하여 펌웨어 업데이트를 수행할 때에도 주의해야 합니다. 업데이트 파일이 장치와 호환되는지 확인하고, 업데이트 모드에서는 다른 프로그램이나 작업을 수행하지 않도록 주의해야 합니다. 또한, 업데이트 과정에서 발생하는 오류를 적극적으로 확인하고, 오류를 수정하도록 노력해야 합니다.

펌웨어 업데이트 과정에서 지정하는 주소값은 업데이트 파일의 위치를 가리킵니다. 일반적으로 이 주소값은 플래시 메모리의 시작 주소를 나타냅니다.

플래시 메모리는 컴퓨터나 기타 디지털 장치에서 비휘발성 저장 장치로 사용됩니다. 이 메모리에는 기기에서 사용되는 소프트웨어 및 데이터가 저장됩니다. 펌웨어 업데이트를 수행하면 새로운 펌웨어 버전이 플래시 메모리에 새롭게 기록되어야 하므로, 업데이트 파일의 위치를 알려주는 것입니다.

이 주소값은 업데이트 파일의 바이너리 형식을 로드하기 위한 시작점을 나타내며, 이 위치부터 파일의 데이터가 플래시 메모리에 기록됩니다. 이렇게 업데이트 파일의 데이터가 플래시 메모리에 정확하게 로드되어야만, 새로운 펌웨어가 정상적으로 작동할 수 있습니다.

elf, hex, bin 파일

모두 컴퓨터에서 사용되는 바이너리 파일의 형식을 나타냅니다.

이러한 바이너리 파일 형식은 주로 소프트웨어나 하드웨어를 개발하는 과정에서 사용됩니다.

ELF (Executable and Linkable Format): ELF는 리눅스와 유닉스 운영체제에서 사용되는 실행 가능한 형식의 바이너리 파일입니다. ELF 파일은 컴파일된 프로그램의 코드, 데이터 및 기타 정보를 포함하며, 여러 가지 섹션으로 구성됩니다. ELF 파일은 실행 파일 또는 공유 라이브러리 파일로 사용됩니다.

HEX (Hexadecimal): HEX 파일은 16진수 형식으로 표현된 데이터를 담고 있는 파일입니다. 이 파일 형식은 프로그래머가 마이크로컨트롤러나 기타 임베디드 시스템에서 사용하는 프로그램 및 데이터를 포함하는 데 사용됩니다. HEX 파일은 텍스트 파일로 쉽게 열어 볼 수 있습니다.

BIN (Binary): BIN 파일은 이진 형식으로 인코딩된 데이터를 담고 있는 파일입니다. BIN 파일은 주로 하드웨어에서 사용되는 펌웨어나 바이너리 이미지를 포함하는 데 사용됩니다. BIN 파일은 이진 파일 형식으로, 텍스트 에디터로 열기 어려울 수 있습니다.

말하자면, ELF 파일은 실행 가능한 형식의 바이너리 파일이고, HEX 파일은 데이터를 16진수 형식으로 인코딩한 파일입니다.

BIN 파일은 이진 형식으로 인코딩된 데이터를 포함하는 파일입니다. 각각의 파일 형식은 사용되는 환경이나 목적에 따라 다르게 사용됩니다

RPC(Remote procedure call) server 란?

꼬북칩조아 — Tue, 4 Apr 2023 04:24:27 +0900

RPC 프로토콜

RPC (Remote Procedure Call) 프로토콜은 클라이언트 애플리케이션이 서버 애플리케이션에서 함수를 호출하고, 이를 처리한 결과를 반환하는 프로토콜입니다. 이를 통해 클라이언트와 서버 간의 통신이 표준화되고, 보안성과 안정성이 확보됩니다.

RPC 프로토콜은 일반적으로 클라이언트와 서버 간의 통신을 위해 사용되는 네트워크 프로토콜인 TCP/IP, UDP 등을 기반으로 구현됩니다. 클라이언트에서 호출하는 함수의 매개변수는 프로토콜을 통해 서버로 전송되고, 서버에서는 이를 처리한 결과를 클라이언트로 반환합니다.

RPC 프로토콜은 다양한 언어와 운영 체제에서 사용될 수 있으며, 서로 다른 애플리케이션 간의 통신에 사용됩니다. 일반적으로 RPC 프로토콜은 클라이언트와 서버 간의 인터페이스를 정의하는 IDL (Interface Definition Language)을 사용하여 통신을 표준화합니다.

RPC 프로토콜은 분산 시스템 및 마이크로서비스 아키텍처에서 매우 중요한 역할을 합니다. 서로 다른 애플리케이션 간의 통신을 단순화하고, 효율적으로 처리할 수 있는 기능을 제공합니다

RPC 서버

RPC (Remote Procedure Call) 서버는 클라이언트 애플리케이션에서 서버 애플리케이션으로 함수를 호출하는 방식입니다. 이 서버를 사용하여 클라이언트 애플리케이션이 서버 측에서 제공하는 함수를 호출하고, 서버에서는 이를 처리하고 결과를 반환합니다.

RPC 서버는 일반적으로 클라이언트와 서버 간의 통신 프로토콜로 RPC를 사용합니다. 이를 통해 클라이언트와 서버 간의 통신이 표준화되고, 보안성과 안정성이 확보됩니다. 또한, 서버 측에서는 여러 클라이언트로부터 요청을 받아 처리할 수 있습니다.

RPC 서버는 다양한 운영 체제와 언어를 지원하며, 이를 사용하여 다른 애플리케이션과 상호작용할 수 있습니다. 이를 통해 다른 애플리케이션과의 연동이 가능해져, 보다 효율적이고 유연한 시스템 구축이 가능해집니다.

RPC 서버는 일반적으로 다음과 같은 단계로 작동합니다.

1. 서버는 RPC 호출을 수신할 수 있는 네트워크 포트를 열고 대기합니다.
2. 클라이언트 애플리케이션에서 RPC 요청을 생성하고, 해당 요청을 서버로 전송합니다.
3. 서버는 RPC 요청을 수신하고, 요청에 따른 함수를 호출합니다.
4. 서버에서는 함수 호출 결과를 클라이언트로 반환합니다.
5. 클라이언트는 서버에서 반환된 결과를 수신하고, 이를 처리합니다.

RPC 서버는 분산 시스템 및 마이크로서비스 아키텍처에서 매우 중요한 역할을 합니다.

서로 다른 서버 간의 통신을 단순화하고, 효율적으로 처리할 수 있는 기능을 제공합니다

RPC 프로토콜은 다양한 분야에서 사용되며, 분산 시스템 및 마이크로서비스 아키텍처에서 중요한 역할을 하고 있습니다.

1. Apache Thrift
Facebook에서 개발한 RPC 프레임워크로, 다양한 언어 및 플랫폼에서 사용할 수 있습니다.
Facebook의 분산 시스템에서 사용되며, Hadoop, Cassandra, Elasticsearch 등 여러 대규모 시스템에서 사용됩니다.
2. gRPC
Google에서 개발한 오픈소스 RPC 프레임워크로, Protocol Buffers를 기반으로 구현되어 있습니다. 이를 사용하여 Google의 다양한 서비스에서 사용되며, 대규모 클라우드 기반 시스템에서 효율적인 통신을 지원합니다.
3. CORBA(Common Object Request Broker Architecture)
OMG(Object Management Group)에서 개발한 분산 객체 프레임워크로, 다양한 언어와 플랫폼에서 사용됩니다. 이를 사용하여 대규모 분산 시스템에서 객체 간의 통신을 효율적으로 처리할 수 있습니다.
4. XML-RPC
XML을 기반으로 하는 RPC 프로토콜로, 다양한 언어와 플랫폼에서 사용됩니다. 이를 사용하여 원격으로 데이터를 읽고 쓰는 데 사용됩니다.
5. JSON-RPC
JSON을 기반으로 하는 경량 RPC 프로토콜로, 다양한 언어와 플랫폼에서 사용됩니다. 이를 사용하여 클라이언트와 서버 간의 효율적인 통신을 지원합니다.

일반 서버-클라이언트 모델과 차이점

RPC 서버는 일반 서버-클라이언트 모델의 서버와는 몇 가지 다른 점이 있습니다.

일반 서버-클라이언트 모델에서는 클라이언트가 서버에 직접 연결하여 요청(request)을 보내고, 서버는 해당 요청을 받아 처리한 후 클라이언트에게 응답(response)을 보내는 방식으로 동작합니다.

반면 RPC 서버는 클라이언트와 서버 간의 통신에서 Remote Procedure Call (RPC) 프로토콜을 사용하기 때문에, 클라이언트가 서버의 메소드(method)를 로컬에서 호출하는 것과 유사한 방식으로 동작하며, 클라이언트는 서버의 메소드를 직접 호출하지 않고, 클라이언트 스텁(client stub)을 통해 서버의 메소드를 호출합니다.

서버는 클라이언트로부터 요청을 받아 해당 메소드를 실행한 후, 결과를 클라이언트에게 응답합니다.즉, RPC 서버는 일반 서버-클라이언트 모델의 서버보다는 높은 수준의 추상화(abstraction)를 제공하며, 클라이언트-서버 간의 통신을 쉽게 처리할 수 있도록 도와줍니다.

이러한 RPC 프로토콜은 대부분의 프로그래밍 언어에서 지원되며, 다양한 RPC 프레임워크가 존재합니다.

이러한 RPC 서버의 장점과 단점은 다음과 같습니다.
장점
1. 분산 시스템을 쉽게 구축할 수 있습니다.
RPC 서버는 다수의 클라이언트가 분산된 환경에서 서로 다른 서버의 기능을 사용할 수 있도록 해주기 때문에
분산 시스템을 구축하는 데 있어서 유용합니다.
2. 프로그래밍 언어와 플랫폼에 독립적입니다.
RPC 서버는 다양한 프로그래밍 언어와 플랫폼에서 동작할 수 있도록 설계되어 있습니다.
따라서 서로 다른 언어와 플랫폼에서 개발된 클라이언트가 같은 RPC 서버를 사용할 수 있습니다.
3. 간단한 프로세스 간 통신을 제공합니다.
RPC 서버는 다른 프로세스 간의 통신을 추상화하여 제공합니다.
이를 통해 클라이언트와 서버 간의 통신을 쉽게 처리할 수 있습니다.
4. 유연하고 확장 가능한 시스템을 구축할 수 있습니다.
RPC 서버는 시스템을 유연하고 확장 가능하게 구축할 수 있도록 도와줍니다. 새로운 기능을 추가하거나 기존 기능을 업그레이드할 때 RPC 인터페이스만 수정하면 되기 때문입니다.

단점
1. 성능 문제가 발생할 수 있습니다.
RPC 서버는 다른 프로세스 간의 통신을 추상화하기 때문에, 일반적인 서버-클라이언트 모델보다 더 많은 오버헤드가 발생할 수 있습니다. 이는 서버의 처리량과 응답 속도에 영향을 미칠 수 있습니다.
2. 디버깅이 어려울 수 있습니다.
RPC 서버는 서로 다른 프로세스 간의 통신을 추상화하므로, 디버깅이 어려울 수 있습니다. 클라이언트와 서버 간의 통신 문제를 해결하기 위해서는 네트워크 트래픽을 모니터링하거나, 로그를 수집해야 할 수도 있습니다.보안 문제가 발생할 수 있습니다.
3. RPC 서버는 클라이언트와 서버 간의 통신을 암호화하거나 보안 기능을 제공하지 않습니다.
따라서 보안 요구사항이 높은 시스템에서는 추가적인 보안 조치를 취해야 할 수도 있습니다.

아래는 Google에서 개발한 gRPC 프레임워크를 사용하여 RPC 서버 및 클라이언트를 구현한 예제입니다.

서버

#include <iostream>
#include <boost/asio.hpp>
#include "rpc.hpp"

int on_add(int x, int y) {
    return x + y;
}

int main() {
    boost::asio::io_service io_service;
    RpcServer server(io_service, 12345);
    server.register_handler("add", on_add);
    server.start();
    std::cout << "Server started." << std::endl;
    io_service.run();
    return 0;
}

on_add 함수 : 클라이언트가 add 메서드를 호출하면, 서버에서 실행되는 함수입니다.
이 함수는 두 개의 정수를 인자로 받아 더한 결과를 반환합니다.
main 함수 : 서버의 메인 함수입니다. io_service 객체를 생성하고, RpcServer 객체를 생성한 뒤 start 메서드를 호출하여 서버를 시작합니다.

클라이언트

#include <iostream>
#include <boost/asio.hpp>
#include "rpc.hpp"

int main() {
    boost::asio::io_service io_service;
    RpcClient client(io_service, "localhost", 12345);
    int result = client.call<int>("add", 1, 2);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

main 함수 : 클라이언트의 메인 함수입니다.
io_service 객체를 생성하고, RpcClient 객체를 생성한 뒤 call 메서드를 호출하여 서버의 add 메서드를 호출합니다.

RPC

#include <string>
#include <functional>
#include <boost/asio.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>

class Message {
public:
    std::string method;
    std::vector<std::string> params;

    Message() {}

    Message(const std::string& method, const std::vector<std::string>& params)
        : method(method), params(params) {}

    std::string to_string() const {
        std::string result = method + "(";
        for (size_t i = 0; i < params.size(); ++i) {
            result += params[i];
            if (i < params.size() - 1) {
                result += ",";
            }
        }
        result += ")";
        return result;
    }

    static Message from_string(const std::string& str) {
        Message msg;
        size_t left_paren = str.find("(");
        size_t right_paren = str.find(")");
        if (left_paren == std::string::npos || right_paren == std::string::npos) {
            return msg;
        }
        msg.method = str.substr(0, left_paren);
        std::string params_str = str.substr(left_paren + 1, right_paren - left_paren - 1);
        size_t pos = 0;
        while (pos < params_str.size()) {
            size_t comma = params_str.find(",", pos);
            if (comma == std::string::npos) {
                comma = params_str.size();
            }
            std::string param = params_str.substr(pos, comma - pos);
            msg.params.push_back(param);
            pos = comma + 1;
        }
        return msg;
    }
};
class RpcServer {
public:
    RpcServer(boost::asio::io_service& io_service, unsigned short port)
        : acceptor_(io_service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
          socket_(io_service) {}

    void register_handler(const std::string& method, std::function<int(int,int)> handler) {
        handlers_[method] = handler;
    }

    void start() {
        do_accept();
    }

private:
    void do_accept() {
        acceptor_.async_accept(socket_, [this](const boost::system::error_code& error) {
            if (!error) {
                std::make_shared<Session>(std::move(socket_), handlers_)->start();
            }
            do_accept();
        });
    }

private:
    boost::asio::ip::tcp::acceptor acceptor_;
    boost::asio::ip::tcp::socket socket_;
    std::map<std::string, std::function<int(int,int)>> handlers_;
};

class RpcClient {
public:
    RpcClient(boost::asio::io_service& io_service, const std::string& host, unsigned short port)
        : io_service_(io_service), socket_(io_service) {
        boost::asio::ip::tcp::resolver resolver(io_service);
        boost::asio::ip::tcp::resolver::query query(host, boost::lexical_cast<std::string>(port));
        boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
        boost::asio::connect(socket_, endpoint_iterator);
    }

    template<typename Result, typename... Args>
    Result call(const std::string& method, Args... args) {
        Message request(method, { boost::lexical_cast<std::string>(args)... });
        std::string request_str = request.to_string();
        boost::asio::write(socket_, boost::asio::buffer(request_str));
        char response_buf[1024];
        size_t response_len = socket_.read_some(boost::asio::buffer(response_buf, sizeof(response_buf)));
        std::string response_str(response_buf, response_len);
        Message response = Message::from_string(response_str);
        return boost::lexical_cast<Result>(response.params[0]);
    }

private:
    boost::asio::io_service& io_service_;
    boost::asio::ip::tcp::socket socket_;
};

Message 클래스
클라이언트와 서버 간에 전송되는 메시지를 나타내는 클래스입니다.
method와 params 멤버 변수를 가지며, to_string 메서드를 통해 문자열 형태로 직렬화할 수 있습니다.
RpcServer 클래스
RPC 서버를 나타내는 클래스입니다. start 메서드를 통해 서버를 시작하며, 클라이언트의 요청이 들어오면 해당 메서드를 실행하고 결과를 반환합니다.
RpcClient 클래스
RPC 클라이언트를 나타내는 클래스입니다. call 메서드를 통해 서버의 메서드를 호출하고 결과를 반환합니다.

하이퍼바이저(hypervisor) 와 도커(docker)

꼬북칩조아 — Tue, 4 Apr 2023 03:47:47 +0900

하이퍼바이저(hypervisor)

하이퍼바이저(Hypervisor)는 가상화 소프트웨어로, 컴퓨터 시스템에서 여러 개의 가상 머신(VM)을 생성하고 관리하는 역할을 합니다.

즉, 가상 머신을 실행하기 위한 소프트웨어입니다

하이퍼바이저는 호스트 시스템(컴퓨터)에서 가상 머신을 만들고 호스트의 리소스를 가상 머신들에게 할당하고, 가상 머신들이 호스트 시스템의 하드웨어 자원(CPU, 메모리, 저장소)을 공유하며 동작할 수 있도록 합니다. 이를 통해 여러 개의 운영 체제(OS)나 응용 프로그램을 단일 물리적 시스템에서 실행할 수 있게 됩니다 (단일 시스템 상에서 독립된 운영체제와 애플리케이션 실행 가능)

하이퍼바이저는 두 가지 유형이 있습니다.

첫 번째는 Type 1 또는 네이티브 하이퍼바이저이고, 두 번째는 Type 2 또는 호스트 기반 하이퍼바이저입니다.

Type 1 하이퍼바이저는 직접 하드웨어 위에 설치되고, 가상 머신의 하드웨어 리소스를 직접 제어합니다. 이러한 하이퍼바이저는 호스트 시스템과 가상 머신 간의 강력한 격리 기능을 제공하며, 가상 머신에서 실행되는 애플리케이션에 대한 고도의 제어를 제공합니다.

Type 2 하이퍼바이저는 호스트 운영 체제 위에 설치되고, 호스트 시스템의 리소스를 공유합니다. 이러한 하이퍼바이저는 더 쉽게 설치할 수 있으며, 일부 경우에는 Type 1 하이퍼바이저보다 더 빠릅니다. 그러나 Type 2 하이퍼바이저는 호스트 시스템의 보안 취약점을 노출할 수 있으며, 가상 머신 간의 격리 기능도 덜 강력합니다.

리소스 관리

하이퍼바이저는 가상 머신의 리소스를 관리하고, 가상 머신 간의 상호작용을 관리합니다. 즉, 각 가상 머신에 할당된 가상 CPU, 메모리, 저장소 등의 리소스를 추적하고, 이 리소스를 가상 머신 간에 균등하게 분배합니다. 또한, 가상 머신 간의 네트워크 연결을 관리하며, 이를 통해 가상 머신 간의 통신을 가능하게 합니다.

I/O 작업 관리

가상 머신은 호스트 시스템의 하드웨어 리소스를 사용하므로, 하이퍼바이저는 가상 머신과 호스트 시스템 간의 I/O 작업을 조정합니다. 예를 들어, 가상 머신에서 디스크 작업을 수행하려면, 하이퍼바이저는 호스트 시스템의 디스크 드라이브에 대한 액세스 권한을 부여하고, 가상 머신이 사용할 수 있도록 가상 디스크 드라이브를 제공합니다.

가상 머신 보안

하이퍼바이저는 가상 머신의 보안을 유지하기 위해 다양한 보안 기술을 사용합니다. 예를 들어, 하이퍼바이저는 가상 머신 간의 통신을 제어하고, 가상 머신의 메모리에 대한 엄격한 접근 권한을 부여하여 가상 머신에서 실행되는 애플리케이션의 보안을 강화합니다

가상 머신의 상태 관리

가상 머신은 일반적으로 운영 체제 및 애플리케이션과 같은 복잡한 시스템을 실행하므로, 하이퍼바이저는 가상 머신의 상태를 모니터링하고, 문제가 발생할 경우에는 가상 머신을 재부팅하거나 복구하는 등의 조치를 취합니다.

이처럼, 하이퍼바이저는 가상 머신을 실행하는 데 필요한 모든 기능을 제공합니다. 가상 머신은 하이퍼바이저 위에 생성되므로, 각 가상 머신은 독립적으로 실행될 수 있습니다. 이러한 구성은 클라우드 컴퓨팅, 서버 가상화, 테스트 및 개발 등 다양한 용도로 사용됩니다.

하이퍼바이저는 가상화 기술의 핵심 기술로, 다양하게 사용되고 있습니다.

1. 서버 가상화
기업에서는 하이퍼바이저를 사용하여 하나의 서버를 여러 개의 가상 서버로 분할하여 사용합니다. 이를 통해 기업은 서버의 사용률을 높이고, 물리적 서버의 수를 줄이면서 IT 인프라의 비용을 절감할 수 있습니다.
2. 클라우드 컴퓨팅
클라우드 컴퓨팅은 인터넷을 통해 IT 리소스를 제공하는 서비스입니다. 하이퍼바이저를 사용하여 클라우드 컴퓨팅 환경을 구축하면, 여러 사용자가 동시에 클라우드 인프라를 공유할 수 있습니다. 이를 통해 기업은 더 많은 고객에게 서비스를 제공하면서 인프라 비용을 절감할 수 있습니다.
3. 테스트 및 개발
하이퍼바이저를 사용하여 테스트 및 개발 환경을 구축하면, 여러 개의 테스트 환경을 동시에 실행할 수 있습니다. 이를 통해 애플리케이션을 더 빠르게 개발하고, 오류를 더 쉽게 수정할 수 있습니다.
4. 보안
하이퍼바이저를 사용하여 가상 머신을 분리하면, 서로 다른 보안 수준을 필요로 하는 애플리케이션을 실행할 수 있습니다. 이를 통해 기업은 보안을 강화하고, 서로 다른 애플리케이션 간의 상호 간섭을 방지할 수 있습니다.
5. 모바일 기술
하이퍼바이저는 모바일 기술에서도 널리 사용됩니다. 예를 들어, BYOD(Bring Your Own Device) 환경에서는 하이퍼바이저를 사용하여 기업 데이터와 개인 데이터를 분리할 수 있습니다. 이를 통해 기업은 보안을 유지하면서도 직원이 자신의 디바이스를 사용할 수 있도록 합니다.

VMware
가상화 기술을 기반으로 한 서버 가상화 솔루션을 제공합니다.
이를 통해 서버의 하드웨어 리소스를 효율적으로 활용하고, 서버의 가용성과 안정성을 높일 수 있습니다.
Microsoft Hyper-V
윈도우 서버 가상화 기술을 제공합니다. 서버 가상화 및 서버 운영 관리를 효율적으로 수행할 수 있습니다.
Citrix XenServer
오픈소스 가상화 플랫폼으로, 클라우드 컴퓨팅 및 가상 데스크톱 인프라를 제공합니다.
이를 통해 클라우드 인프라 및 가상 데스크톱 인프라를 효율적으로 관리하고, 자원의 활용도를 높일 수 있습니다.
Oracle VM VirtualBox
데스크톱 가상화 플랫폼으로, 다양한 운영체제를 호스팅하는 가상 머신을 만들 수 있습니다.
테스트 및 개발 환경 구축을 용이하게 할 수 있습니다.
IBM z/VM
메인프레임 가상화 플랫폼으로, 메인프레임의 자원을 효율적으로 관리하고, 가상 서버를 만들어서 다양한 운영체제 및 어플리케이션을 호스팅할 수 있습니다. 이를 통해 메인프레임의 가용성과 안정성을 높일 수 있습니다

도커(docker)

Docker는 컨테이너 기반의 가상화 기술을 사용하여 응용 프로그램을 패키징하고 실행하는 플랫폼입니다.

컨테이너는 가상화된 환경에서 응용 프로그램을 실행할 수 있도록 격리된 공간을 제공합니다. 이러한 격리된 공간에서는 응용 프로그램이 필요로 하는 라이브러리, 파일 시스템 등의 환경을 포함한 모든 것이 패키징되어 있습니다.

Docker는 이러한 컨테이너 기반의 가상화 기술을 사용하여 응용 프로그램을 패키징하고 배포할 수 있도록 도와주는 플랫폼입니다. Docker는 호스트 운영 체제와 컨테이너 간의 직접적인 상호작용을 통해 응용 프로그램을 실행합니다.

이처럼 Docker는 하이퍼바이저(가상 머신 기반의 가상화)와는 다른 방식으로 응용 프로그램을 가상화합니다

Docker는 컨테이너라는 가상화 기술을 사용하여 응용 프로그램을 패키징하고 실행하는 것을 지원합니다.
Docker는 다음과 같은 원리로 동작합니다.

1. 이미지 작성
Docker 이미지는 응용 프로그램과 그 실행 환경을 포함하는 것입니다. Dockerfile이라는 특별한 파일 형식을 사용하여 Docker 이미지를 작성합니다. Dockerfile은 응용 프로그램 실행에 필요한 파일, 라이브러리, 환경 변수, 포트 등을 정의합니다.
2. 이미지 빌드
Dockerfile을 사용하여 Docker 이미지를 빌드합니다. Docker는 Dockerfile에 정의된 내용에 따라 이미지를 빌드하고, 필요한 파일과 라이브러리 등을 다운로드합니다. 이미지를 빌드한 후에는 해당 이미지를 Docker 레지스트리에 업로드하거나 다른 사용자와 공유할 수 있습니다.
3. 컨테이너 실행
Docker 이미지를 사용하여 컨테이너를 실행합니다. 이때 컨테이너는 호스트 운영 체제의 자원을 사용합니다. Docker는 컨테이너 실행에 필요한 모든 자원을 미리 준비하여 컨테이너가 실행될 때 즉시 사용할 수 있도록 합니다.
4. 컨테이너 관리
Docker는 컨테이너를 관리하기 위한 명령어를 제공합니다. 이를 사용하여 컨테이너를 시작, 중지, 재시작하고, 로그를 볼 수 있습니다. Docker는 또한 컨테이너 간의 통신을 지원합니다.
5. 네트워크
Docker는 기본적으로 호스트 운영 체제와 동일한 네트워크에 컨테이너를 배치합니다. 이는 컨테이너 간의 통신을 간편하게 만들어 줍니다. Docker는 또한 다른 네트워크와의 연결을 지원합니다.
6. 데이터 관리
Docker는 컨테이너에서 생성되는 데이터를 관리하기 위해 볼륨이라는 개념을 제공합니다. 볼륨은 컨테이너와 호스트 운영 체제 사이의 데이터 공유를 가능하게 합니다.
Docker는 이러한 방식으로 컨테이너화된 응용 프로그램을 실행하고 관리합니다. 이는 가볍고 빠른 실행 속도, 쉬운 배포, 높은 이식성 등의 장점을 제공합니다.

Docker는 다양한 용도로 사용될 수 있습니다. 일부 일반적인 사용 사례는 다음과 같습니다.

애플리케이션 배포
Docker는 애플리케이션을 가상 컨테이너로 패키징하여 배포하는 데 이상적입니다. 이렇게 하면 애플리케이션을 호스트 운영 체제에 영향을 주지 않고 실행할 수 있으며, 호스트 운영 체제에 설치된 의존성 라이브러리의 충돌 문제를 해결할 수 있습니다.

서비스 분리
Docker는 서비스를 분리하여 실행하고, 서비스 간의 의존성을 관리하는 데도 유용합니다. 예를 들어, 웹 애플리케이션의 프론트엔드와 백엔드를 분리하여 각각 Docker 컨테이너로 실행하면, 서로 다른 호스트에서도 실행할 수 있고, 확장성과 격리성이 개선됩니다.

개발 환경 구성
Docker는 개발 환경 구성을 간편하게 만들어 줍니다. Docker를 사용하면 개발자는 개발에 필요한 환경을 Docker 이미지로 빌드하여 다른 개발자와 공유할 수 있습니다. 이렇게 하면 개발자는 개발 환경을 쉽게 설정하고, 이식성이 개선됩니다.

테스트 환경 구성
Docker를 사용하면 테스트 환경 구성도 간편해집니다. 개발자는 테스트를 위한 Docker 이미지를 빌드하여 테스트 서버에서 실행할 수 있습니다. 이렇게 하면 테스트 서버에 일시적인 의존성을 설치하지 않아도 되므로, 서버 관리가 더욱 용이해집니다.

마이그레이션
Docker를 사용하면 더 나은 성능을 제공하는 새로운 운영 체제나 호스트로 마이그레이션하는 것이 용이해집니다. 애플리케이션과 의존성을 Docker 이미지로 패키징하면, 이미지를 다른 호스트로 이동하여 쉽게 배포할 수 있습니다.
위와 같은 방식으로 Docker는 여러 분야에서 사용되고 있습니다. Docker는 컨테이너 기술을 통해 애플리케이션 실행 및 관리를 간편하게 해주므로, 인기 있는 기술 중 하나입니다.

Airbnb
Airbnb는 도커를 사용하여 마이크로서비스 아키텍처를 구현하고 서비스를 컨테이너화하여 배포하고 있습니다.
이를 통해 서비스의 가용성과 안정성을 높였으며, 인프라 관리 및 개발과 배포 과정을 효율화했습니다.

Spotify
Spotify는 도커를 사용하여 서버 인프라를 관리하고 있습니다. 이를 통해 개발과 배포 과정을 효율화하고,
서비스를 더 빠르게 출시하고, 확장성과 안정성을 높였습니다.

Uber
Uber는 도커를 사용하여 개발 및 배포를 자동화하고, 서버 인프라를 관리하고 있습니다.
이를 통해 개발 및 배포 과정을 효율화하고, 서비스의 안정성과 가용성을 높였습니다.

NASA
NASA는 도커를 사용하여 우주선과 로봇 운영을 위한 소프트웨어를 개발하고 있습니다.
이를 통해 소프트웨어를 더 안정적으로 운영할 수 있으며, 운영 비용을 줄일 수 있습니다.

eBay
eBay는 도커를 사용하여 마이크로서비스 아키텍처를 구현하고, 서비스를 컨테이너화하여 배포하고 있습니다.
이를 통해 개발과 배포 과정을 효율화하고, 서비스의 안정성과 가용성을 높였습니다.

하이퍼바이저와 도커

Docker와 하이퍼바이저는 모두 가상화 기술을 사용하여 응용 프로그램을 실행하는 기술입니다.

하지만, Docker와 하이퍼바이저는 큰 차이점이 있습니다.

가상화 방식
하이퍼바이저는 가상 머신을 생성하고, 각 가상 머신에 운영 체제를 설치하여 실행합니다. 따라서 가상 머신마다 자원과 운영 체제가 필요합니다. 이는 가상 머신을 사용하는 데 있어서 상대적으로 더 많은 자원이 필요하다는 것을 의미합니다.
반면 Docker는 호스트 운영 체제 위에서 동작합니다. Docker는 컨테이너라는 가벼운 가상화 기술을 사용하여 응용 프로그램을 패키징하고 실행합니다. 따라서 Docker는 가상 머신처럼 각각의 운영 체제를 설치하는 것이 아니라, 호스트 운영 체제의 커널을 공유하여 실행합니다. 이는 매우 가볍고 빠르게 실행할 수 있다는 것을 의미합니다.

성능
하이퍼바이저는 각 가상 머신이 독립적인 운영 체제를 가지므로 자원이 더 많이 필요합니다. 또한 가상 머신 사이에 자원을 분할하고 조정하는 작업이 필요합니다. 이는 상대적으로 느린 실행 속도를 가져올 수 있습니다.
한편, Docker는 호스트 운영 체제에서 실행되므로 가상 머신과는 달리 호스트와 컨테이너 간의 자원 분할과 조정이 필요하지 않습니다. 또한 컨테이너는 각각의 운영 체제를 가지지 않으므로, 가상 머신보다 상대적으로 더 빠르게 실행할 수 있습니다.

이미지 관리 방식
하이퍼바이저는 가상 머신 이미지를 사용하여 가상 머신을 생성합니다. 이는 대부분의 경우 ISO 파일로 제공됩니다. 새로운 가상 머신을 만들 때마다 이미지를 다운로드하고 설치해야 합니다. 이는 이미지 관리가 번거롭고 불편할 수 있다는 것을 의미합니다.
그런데 Docker는 컨테이너 이미지를 사용하여 응용 프로그램을 패키징하고 배포합니다. 이러한 이미지는 Docker Hub와 같은 저장소에서 공유되어 사용할 수 있습니다

static / dynamic library (shared object) 와 링킹(linking)

꼬북칩조아 — Mon, 3 Apr 2023 07:54:55 +0900

라이브러리(library)란?

라이브러리(library)란 다른 프로그램에서 사용할 수 있는 코드의 모음을 의미합니다.

라이브러리를 만들기 위해서는 헤더 파일과 라이브러리를 구성하는 코드가 필요합니다. 헤더 파일은 사용자가 라이브러리를 사용하기 위해 호출할 함수와 변수의 프로토타입을 선언하며, 라이브러리 코드는 실제로 함수와 변수를 구현하는 코드입니다.

헤더 파일과 라이브러리 코드를 함께 컴파일하여 정적 라이브러리 또는 동적 라이브러리를 생성할 수 있습니다. 이때, 라이브러리 코드는 오브젝트 파일 형태로 제공되며, 라이브러리를 사용하는 프로그램은 이 오브젝트 파일을 링크하여 라이브러리를 사용할 수 있습니다.

헤더 파일은 라이브러리를 사용하는 사용자가 라이브러리를 쉽게 사용할 수 있도록 인터페이스를 제공합니다. 이를 통해 라이브러리를 사용하는 사용자는 라이브러리를 사용하는데 필요한 함수와 변수의 이름, 매개변수, 반환값 등을 알 수 있습니다. 또한, 헤더 파일은 라이브러리를 구현하는 소스 코드와 사용자 코드 간의 인터페이스를 명확히 하여 코드의 가독성과 유지보수성을 높이는 역할도 합니다.

따라서, 헤더 파일은 라이브러리를 사용하는 사용자가 라이브러리를 사용하기 위한 필수적인 정보를 제공하는 역할을 하기 때문에 따로 구분하여 사용합니다. 라이브러리를 만드는 개발자는 헤더 파일을 작성하여 라이브러리의 인터페이스를 제공하고, 라이브러리를 사용하는 사용자는 해당 헤더 파일을 include하여 라이브러리를 사용할 수 있습니다. 이를 통해 라이브러리를 쉽게 사용할 수 있으며, 라이브러리를 수정하더라도 헤더 파일만 수정하면 라이브러리를 사용하는 모든 코드에 영향을 주지 않습니다.

이렇게 만들어진 라이브러리는 여러 프로그램에서 재사용되어 코드의 중복을 막고 개발 시간을 단축시키는 등의 이점을 제공합니다.

라이브러리는 크게 static library와 dynamic library로 나눌 수 있습니다.

1. static library
Static 라이브러리는 컴파일 시에 라이브러리의 코드가 사용자의 프로그램에 복사되어 실행 파일에 포함됩니다.
이 때, 실행 파일은 라이브러리를 사용할 때마다 그 라이브러리의 모든 코드를 메모리에 로드합니다.
따라서, 여러 프로그램에서 같은 라이브러리를 사용하는 경우, 메모리를 많이 차지할 수 있습니다.
Static 라이브러리는 사용자가 컴파일러에게 직접 링크하도록 지정하는 방법으로 사용할 수 있습니다.
이 경우, 사용자의 소스 코드와 함께 실행 파일에 라이브러리 코드가 포함됩니다.
이러한 방식은 실행 파일의 크기가 크다는 단점이 있지만, 실행 파일이 라이브러리 파일에 의존하지 않으므로 이식성이 높습니다.

2. dynamic library
Dynamic 라이브러리는 실행 파일과 별도로 존재하며, 프로그램이 실행될 때 메모리에 로드됩니다.
따라서, 라이브러리의 코드는 여러 프로그램에서 공유될 수 있습니다.
이렇게 공유된 라이브러리는 메모리를 적게 사용할 수 있습니다.
Dynamic 라이브러리는 사용자가 라이브러리를 호출할 때마다 동적으로 로드됩니다.
이를 위해 프로그래밍 언어에 따라서는 로딩에 대한 명시적인 호출이 필요할 수 있습니다.
이 방식은 실행 파일의 크기를 줄일 수 있지만, 실행 파일이 라이브러리 파일에 의존한다는 단점이 있습니다.
또한, Dynamic 라이브러리는 라이브러리 코드가 변경될 경우, 실행 파일을 다시 빌드하지 않아도 되므로, 유지보수가 용이합니다. 그러나, 라이브러리 파일이 필요하므로 이식성이 낮을 수 있습니다.

shared object
UNIX 및 유닉스 계열 운영 체제에서 자주 등장하는 용어인 "shard object" 또한 동적 라이브러리(dynamic library)의 일종입니다
즉, Windows 운영 체제에서 사용되는 DLL(Dynamic Link Library)이 유닉스 운영체제에서는 SO(shared object)인 것입니다.
Shared objec 역시 실행 파일과 별도로 존재하는 라이브러리 파일이며, 런타임에 메모리에 로드되어 프로그램에서 사용됩니다.
따라서 여러 프로그램에서 공유될 수 있으므로 메모리를 절약할 수 있습니다. (동적 링크 통해 실행 파일 크기 줄일수 있음)
Shared object는 보통 .so (shared object) 확장자를 갖습니다. 사용자가 컴파일러에게 직접 링크하거나, 런타임에 로드하기 위해 명시적인 호출이 필요합니다.
Shared object는 다양한 용도로 사용될 수 있습니다.
예를 들어, 시스템 라이브러리와 같은 기본적인 함수를 포함하여, user-defined 함수, 플러그인, 응용 프로그램의 모듈 등을 구현 등에 사용될 수 있습니다. 또한, Shared object는 유지보수 및 업그레이드 작업을 용이하게 하므로, 대규모 프로젝트에서 매우 유용합니다.

링킹(linking)

링킹(Linking)은 프로그래밍에서 컴파일된 객체 파일(Object File)을 실행 파일(Executable File)로 결합하는 과정을 말합니다.

일반적으로 컴파일러가 소스 코드를 컴파일하여 오브젝트 파일(Object File)을 생성하면, 이러한 오브젝트 파일은 실행 파일을 만들기 위해 링커(Linker)에 의해 결합됩니다.

링킹은 크게 두 가지 유형이 있습니다.

1. 정적 링킹(Static Linking)
정적 링킹은 컴파일된 오브젝트 파일(Object File)과 라이브러리(Library)를 결합하여 실행 파일(Executable File)을 생성하는 과정입니다. 이 때, 실행 파일은 모든 함수와 라이브러리를 포함하므로, 런타임에 추가적인 라이브러리 로딩이 필요하지 않습니다.
정적 링킹의 장점은 실행 파일이 의존성 문제를 일으키지 않으며, 이식성이 높아진다는 것입니다. 그러나 단점은 실행 파일의 크기가 커질 수 있으며, 여러 프로그램에서 동일한 라이브러리를 사용할 때, 메모리 낭비가 발생할 수 있다는 것입니다.

예를 들어, C 프로그램에서 "math" 라이브러리를 사용하여 삼각함수를 계산한다고 가정해봅시다.

이 경우, 다음과 같은 과정으로 링킹이 수행됩니다.

1. 컴파일러는 소스 코드를 컴파일하여 오브젝트 파일을 생성합니다.
이때, "math.h" 헤더 파일을 포함하여 "sin", "cos", "tan" 함수 등을 호출하면,
컴파일러는 오브젝트 파일에 함수를 호출하는 코드를 생성합니다.
2. 링커는 "math" 라이브러리를 포함하여 실행 파일을 생성합니다.
이때, "math" 라이브러리의 함수가 필요하면, 링커는 "math" 라이브러리에서 해당 함수를 찾아 오브젝트 파일에 결합합니다.
이때, 정적 링킹을 사용한다면, 링커는 "math" 라이브러리에서 해당 함수를 직접 찾아서 실행 파일에 포함시킵니다.
3. 실행 파일이 실행될 때, 필요한 라이브러리와 함수가 이미 실행 파일 내에 포함되어 있으므로,
런타임에 추가적인 라이브러리 로딩이 필요하지 않습니다.

따라서, 정적 라이브러리를 사용하는 경우, 모든 함수와 라이브러리를 실행 파일에 포함시켜 런타임에 추가적인 라이브러리 로딩을 방지하고, 실행 파일의 이식성을 높일 수 있습니다.

2. 동적 링킹(Dynamic Linking)
동적 링킹은 런타임에 필요한 라이브러리를 로드하여 실행 파일(Executable File)을 생성하는 과정입니다. 이 때, 실행 파일은 필요한 라이브러리만 포함하므로, 실행 파일의 크기가 줄어들고, 여러 프로그램에서 공유할 수 있습니다.
동적 링킹의 장점은 실행 파일의 크기가 작고, 메모리 절약 효과가 있다는 것입니다. 그러나 단점은 런타임에 추가적인 라이브러리 로딩이 필요하므로, 실행 시간이 더 오래 걸릴 수 있다는 것입니다.

동적 라이브러리는 실행 파일과 별도로 존재하는 라이브러리로, 실행 파일이 라이브러리를 필요로 할 때에만 로딩되며, 메모리에 올라가서 사용됩니다. 이러한 동적 라이브러리는 링커에 의해 실행 파일에 포함되는 것이 아니라, 실행 파일이 로딩될 때 동적으로 링킹됩니다.

동적 라이브러리 링킹 과정은 크게 두 단계로 나눌 수 있습니다.
첫 번째 단계는 라이브러리를 로딩하는 과정이며, 두 번째 단계는 라이브러리를 실행 파일과 링킹하는 과정입니다.

첫 번째 단계에서는 운영 체제가 라이브러리를 찾아서 메모리에 로딩합니다.
예를 들어, "math" 라이브러리를 동적 라이브러리로 만들어서 사용한다고 가정해봅시다. 이때, 컴파일러가 소스 코드를 컴파일하여 오브젝트 파일을 생성하는 단계에서, "math" 라이브러리의 함수를 호출하는 코드가 생성됩니다. 하지만, 링커는 "math" 라이브러리를 실행 파일에 포함시키지 않습니다.
대신, 실행 파일이 로딩될 때, "math" 라이브러리가 필요한 경우, 운영 체제는 "math" 라이브러리를 로딩하여 해당 함수들을 실행 파일과 링킹합니다. (이 단계에서는 운영 체제가 라이브러리를 찾아서 메모리에 로딩합니다. 이때, 라이브러리는 운영 체제가 지정한 경로에서 찾을 수도 있고, 실행 파일이나 다른 라이브러리에 의해 이미 로딩된 경우에는 해당 라이브러리를 공유하여 사용할 수도 있습니다.)

두 번째 단계에서는 실행 파일과 라이브러리를 링킹합니다.
이때, 실행 파일은 라이브러리가 제공하는 함수와 변수를 사용할 수 있습니다. 이 과정에서는 라이브러리가 제공하는 함수와 변수의 이름과 주소를 실행 파일의 심볼 테이블에 등록합니다. 이후 실행 파일에서 라이브러리의 함수를 호출하면, 실행 파일은 등록된 주소를 참조하여 해당 함수를 실행합니다.

동적 라이브러리를 사용하면, 라이브러리를 로딩하는 시점에 메모리 사용량이 증가하며, 실행 파일과 동적 라이브러리가 모두 필요한 경우 초기 로딩 시간도 더 걸리지만, 실행 파일의 크기를 줄일 수 있으며, 여러 개의 실행 파일에서 동일한 라이브러리를 사용할 경우, 해당 라이브러리의 코드와 데이터가 메모리에 한 번만 로딩되므로 디스크 공간의 낭비를 줄일 수 있습니다.(실행파일과 라이브러리의 호환성 문제가 발생 할 수 있음) 또한, 라이브러리를 업데이트하면, 모든 실행 파일을 다시 컴파일하지 않아도 되며, 새로운 버전의 라이브러리를 로딩하는 실행 파일만 수정하면 됩니다.

링킹은 컴파일러와 링커에 의해 자동으로 수행되지만, 경우에 따라 명시적으로 링커를 호출하여 링킹을 수행할 수도 있습니다. 링킹 과정에서는 중복된 기능을 가진 오브젝트 파일과 라이브러리를 제거하고, 링크 주소를 결정하여 실행 파일을 생성합니다

원어민이 자주쓰는 문장 30개

꼬북칩조아 — Mon, 3 Apr 2023 06:59:50 +0900

1. Take your time : 여유를 가져, 천천히 해

밥 먼저 먹고, 상대한테 천천히 먹으라고 할때

Take your time, I can wait

식당에서 메뉴판을 좀 오래 보고 있을 때 웨이터가

Take your time, I'll be back

밖에서 그렇게 여유 부릴 순 없어요. 돌아오셔야 해요

You can't just take your time out there, you need to get back

2. Never mind : 신경 쓰지마, 아무것도 아니야

*뉘앙스를 잘 살려야햠 : 차가운 어투로 말하면 '신경 꺼'가 될 수 있음. (부드러운 어투로 말할 것)

*비지니스 영어로는 사용하지 않는 것을 권장

A: 뭐하세요?

B: 아... 신경쓰지마세요 이 비디오는..

A: What are you doing?

B: Ahh.. never mind this video is..

3. I'll be right back : 금방(짧은 시간) 돌아올게

A: Microwave's the way

B: I'll be right back

1시간 안에 올게

I'll be back in an hour

30분 안에 올게

I'll be back in 30 minutes

4. Are you ready to ~ ? : ~ 할 준비 됐어요?

식사가 끝나고 상대방도 접시가 빈 것을 확인 한 후 일어나자고 제안할 때

Are you ready to go ?

(웨이터가) 식당에서 손님들에게

Are you ready to order ?

5. I can tell : 보니까 알거 같아 / 보니까 그런거 같아

보다시피 잘 하진 못해.

네 그런것 같네요. 그거나 좀 주실래요?

Not good at this apparently

Yeah. I can tell. Can we have it though?

달라진거 알거 같아?

Can you tell the difference ?

응 너 머리잘랐네

Yeah, I can tell. you cut your hair

네 잡아보니까 차이를 알거같아요

Yeah. I can tell the difference holding it

6. go ahead : 먼저 하세요/ 그렇게 하세요

A: 이거 버리려고

B: 그래 그렇게 해. 어차피 당신 그거 안쓰잖아

A: I was gonna thow it away

B: Go ahead. You never used it anyway

7. Here you go : 여기요

잔돈 건낼 때

*Here we go : 자 이제 가봅시다. 시작해 봅시다

8. Have a good one : 좋은하루 보내세요

말할 때보다 듣는 경우가 많으므로, 대답으로 "you too"(그쪽도요) 라고 하면 됨

A: Have a good one

B: You too

9. I'm down : 좋아요. 동의해요

A: 우리 그냥 이것들 크리스마스 때까지 24시간 걸어둘까?

B: 그래 난 찬성이야

A: Is it okay if we just have this hang in out for 24/7 until Christmas?

B: Yeah, I'm down

피자먹으러 갈래?

I'm down

그거에 대해서는 확실히 동의해요

I'm down for that for sure

10. What's that ? : 뭐라고요? 뭐라고 하셨죠? (+ Can you say that again?)

A: Sorry, what's that ?

B: Didn't you want me to keep talking?

*sorry? 잘못들었습니다 (끝을 올려줘야함)

11. Sounds good : 좋은 생각이야

Sound : ~ 처럼 들린다

Sounds good I'm down.

오늘 커피한잔 하러 갈까? : Do you wanna go get some coffee today ? --> Sounds good

12. My bad : 아이고 미안합니다 (작은 실수에 대해 사과)

I'm sorry 보다 약한 표현

(문 밀고 당기는 상황에서 부딪칠뻔한 상황이나, 스마트폰 보다가 살짝 부딪치거다 부딪칠 뻔한 상황)

A: Oh, My bad

B: That's fine

13. It's(that's) fine : 괜찮아요

사소한 실수에 대해 괜찮다고 대답할 때 (식당에서 음식이 늦게 나와서 미안하다고 할때) ---> It's fine.

옷을 샀는데 어떠냐고 물어보면, 그럭저럭 괜찮다고 표현할 때 --> That's fine. That's OK

14. See you around : 나중에 보자. 또보자

그래 이제 가볼께 나중에 또보자 : Alright I gotta get going we'll see you around

15. have fun : 재밌게 해 , 즐겨

상대방이 놀러간다고 했을때, "재밌게 하세요~"

Go have fun : 재밌게 노세요~

16. What do you mean ? : 무슨 뜻이야? 무슨 말이야?

A: It's not rocket science

B: What do you mean (by that) ?

A: I mean it's not that much difficult

What do you mean by 'accidental'? : 우연이었다는게 무슨 말씀인가요?

17. I'm not sure : 확실하진 않아

영화 언제 개봉하는지 알아?

확실하겐 모르겠는데, 화요일인거 같아

A: Do you know when the movie is released ?

B: I'm not sure. but I think it's tuesday

뭔지는 모르겠는데, 이쁘네요

I'm not sure what that is, but it looks good

18. please let me know : 알려주세요

If you ever need anything just let me know : 필요한거 있으시면 알려주세요

you guys got any questions just let us know : 질문있으시면 말씀하세요

19. No way : 말도 안돼? 진짜? 헐 대박

(약간) 놀랐을 때, 신기한 얘기 들었을 때

20. Take care : 잘 지내, 조심히 가, 몸 조심해

좋은하루 보내시구여 들어가요 : Have a wonderful day. Take care

출처: 유튜브 채널 '하루영어회화'

https://www.youtube.com/watch?v=puwNbyv5CmQ

[C++] std::fstream 의 역할과 작동원리

꼬북칩조아 — Sat, 1 Apr 2023 13:05:19 +0900

std::fstream은 "파일"에 대한 입력 및 출력을 지원하는 클래스로 파일 스트림 클래스라고도 불립니다.

(std::ifstream와 std::ofstream의 기능을 모두 포함하고 있어 파일을 읽고 쓸 수 있습니다)

std::fstream은 <fstream> 헤더 파일에서 정의되며, std::fstream 클래스 내부에 구현된 함수를 사용하여 파일을 열고 닫습니다.

아래는 std::fstream 클래스의 주요 멤버 함수입니다.

open() : 파일을 엽니다.
close() : 파일을 닫습니다.
read() : 파일에서 데이터를 읽습니다.
write() : 파일에 데이터를 씁니다.
seekg() : 파일 내에서 읽기 위치를 이동합니다.
seekp() : 파일 내에서 쓰기 위치를 이동합니다.
tellg() : 읽기 위치를 반환합니다.
tellp() : 쓰기 위치를 반환합니다.
eof() : 파일 끝에 도달했는지 확인합니다.

먼저, 파일을 읽고 쓰는 간단한 코드를 한번 보도록 하겠습니다.

예제: 파일 읽고 쓰 기

#include <iostream>
#include <fstream>

int main() {
    std::fstream fs;
    fs.open("example.txt", std::ios::in | std::ios::out | std::ios::binary);
    if (!fs) {
        std::cout << "파일 열기 실패" << std::endl;
        return 1;
    }
    // 파일 읽기
    char buffer[256];
    fs.read(buffer, 256);
    std::cout << buffer << std::endl;

    // 파일 쓰기
    fs.write("Hello World!", 12);
    fs.close();

    return 0;
}

먼저 fs라는 이름의 fstream 인스턴스를 활용하여 fstream 내부함수인 open 함수를 호출합니다,
파일이름은 example.txt 이고, 파일 처리 방식을 입출력이 모두 가능한 바이너리 형식으로 지정했습니다.
(여러 개의 열기 모드를 지정할 때는 비트 OR 연산자(|)를 사용)
아래는 open 함수의 주요 열기 모드입니다.
ios_base::in : 파일을 읽기 위해 엽니다.
ios_base::out : 파일을 쓰기 위해 엽니다.
ios_base::app : 파일 끝에 추가하기 위해 엽니다.
ios_base::binary : 이진 파일로 엽니다.
파일 읽기에 실패한 경우 읽기 실패에 대한 로깅을 하고 프로그램을 종료하고,
그렇지 않은 경우라면 read 함수로 파일 내용을 읽은 다음 buffer 라는 이름의 배열에 저정한 후 콘솔 출력합니다.
그리고 Hello World! 를 파일 끝에 추가로 쓰고 파일을 닫습니다.

예제 : 로그 파일 생성

로그 파일을 생성할 때는 이전 로그 내용을 보존하면서 새로운 로그 내용을 추가해야 하므로 std::fstream::out | std::fstream::app 모드로 파일을 열어, 새로운 로그 내용이 파일 끝에 추가되게끔 함으로써 이전 로그 내용을 계속 유지할 수 있습니다.

#include <iostream>
#include <fstream>

int main() {
    std::fstream log_file;
    log_file.open("log.txt", std::fstream::out | std::fstream::app);
    if (!log_file.is_open()) {
        std::cerr << "Failed to open log file." << std::endl;
        return -1;
    }
    log_file << "New log message." << std::endl;
    log_file.close();
    return 0;
}

위 예제에서는 log.txt 파일을 쓰기 모드로 열면서 파일 끝에 추가 쓰기 모드를 지정하여 로그 파일에 새로운 로그 메시지를 추가합니다. 만약 파일을 열지 못했을 경우, is_open() 함수를 사용하여 파일이 열렸는지 확인합니다.

fstream과 버퍼

std::fstream은 기능적 특성상 내부적으로 파일 입출력 작업을 위한 버퍼를 가지고 있습니다.

버퍼는 일시적으로 데이터를 저장하고, 저장된 데이터를 파일에 쓰거나 파일에서 읽어들일 때 사용됩니다.

std::fstream 클래스는 내부적으로 두 개의 버퍼를 가지고 있습니다.

하나는 입력 버퍼(input buffer)이고, 다른 하나는 출력 버퍼(output buffer)입니다.

입력 버퍼는 파일에서 읽어들인 데이터를 저장하는데 사용되며, 출력 버퍼는 파일에 쓰기 위한 데이터를 저장하는데 사용됩니다

std::fstream 클래스에서는 버퍼링을 사용하여 입출력 작업의 성능을 향상시킬 수 있습니다.

버퍼링을 사용하면 데이터를 파일에 쓰거나 파일에서 읽어들이는 작업을 수행할 때, 매번 파일에 직접 접근하지 않고 버퍼에 데이터를 저장하거나 버퍼에서 데이터를 읽어들입니다. 이렇게 함으로써 파일 입출력 작업이 더욱 효율적으로 수행될 수 있습니다.

std::fstream 클래스에서는 기본적으로 출력 버퍼링이 사용되며, 입력 버퍼링은 사용되지 않습니다.

즉, 출력 작업은 버퍼에 쌓인 데이터가 일정 크기 이상이 되거나, 파일을 닫을 때까지 버퍼에 저장되어 있게 됩니다.

반면에 입력 작업은 즉시 처리되며, 파일에서 데이터를 읽어들이면 입력 버퍼에 저장하지 않고 즉시 읽어들입니다.

버퍼링을 제어하기 위해서는 std::fstream 클래스의 멤버 함수인 flush()와 rdbuf()를 사용할 수 있습니다.

flush() 함수는 출력 버퍼에 저장된 데이터를 파일에 쓰는 작업을 수행하며, rdbuf() 함수는 입력 및 출력 버퍼에 대한 스트림 버퍼 포인터를 반환합니다. 이를 통해 버퍼를 직접 제어할 수 있습니다.

fstream 내부 버퍼와 운영체제의 버퍼

std::fstream 내부 버퍼와 운영체제(OS)의 버퍼는 서로 독립적으로 작동합니다.

std::fstream 내부 버퍼는 C++ 라이브러리에서 제공되는 버퍼링 기능으로, 입출력 연산의 성능을 향상시키기 위한 것인 반면,

운영체제의 버퍼는 실제 파일 시스템에 접근하여 입출력 연산을 수행하는 데 사용됩니다.

std::fstream 클래스의 객체를 생성하면, 내부적으로 파일과 연결된 운영체제의 파일 디스크립터를 생성하고, 파일 시스템에서 파일을 열

어야 합니다. 이 때, 운영체제는 해당 파일에 대한 버퍼를 생성하여 파일 시스템에서 데이터를 읽어들이거나 쓰기 작업을 수행합니다

std::fstream 클래스에서는 입출력 작업을 수행할 때, 먼저 C++ 내부 버퍼에 데이터를 저장하고, 일정량 이상의 데이터가 쌓이면 운영체제의 버퍼에 데이터를 쓰거나, 운영체제의 버퍼에서 데이터를 읽어들입니다. 이 때, C++ 내부 버퍼와 운영체제의 버퍼는 서로 독립적으로 작동하기 때문에, C++ 내부 버퍼에 데이터를 쓴 후에도, 바로 운영체제의 버퍼에 데이터가 쓰이는 것이 아니라, 내부 버퍼에 데이터가 쌓이게 됩니다. 이후에, 일정량 이상의 데이터가 쌓이면, C++ 라이브러리에서 버퍼의 내용을 운영체제의 버퍼로 옮겨주고, 운영체제의 입출력 함수를 호출하여 실제 파일 시스템에서 데이터를 읽거나 쓰게 됩니다

즉, std::fstream 내부 버퍼와 운영체제의 버퍼는 서로 다른 기능을 수행하면서도, 데이터를 주고받는 과정에서 서로 협력하여 작동합니다. 이러한 구조는 입출력 연산의 성능을 최적화하기 위한 것입니다.

fstream을 통해 파일로부터 데이터를 읽어들일 때 운영체제의 역할

std::fstream 클래스를 사용하여 파일로부터 데이터를 읽어들일 때, 운영체제(OS)는 다음과 같은 역할을 수행합니다

1. 파일 시스템에서 파일을 열기: std::fstream 객체가 생성되면, 운영체제는 파일 시스템에서 해당 파일을 열어야 합니다.
파일이 존재하지 않거나, 권한이 없는 경우 등에는 파일 열기에 실패할 수 있습니다
2. 파일 읽기: 파일이 열리면, std::fstream 클래스의 멤버 함수를 이용하여 데이터를 읽어들일 수 있습니다.
데이터를 읽어들일 때, 운영체제는 해당 파일의 내용을 버퍼에 읽어들입니다.
버퍼는 운영체제의 내부 버퍼와 std::fstream 클래스의 내부 버퍼 두 가지가 있습니다.
3. 버퍼의 데이터를 프로그램으로 복사: 운영체제가 파일의 데이터를 버퍼에 읽어들이면, C++ 라이브러리는 이 데이터를 std::fstream 클래스의 내부 버퍼로 복사합니다. std::fstream 클래스는 내부적으로 버퍼를 사용하여 파일의 데이터를 저장합니다.
이렇게 복사된 데이터는 프로그램에서 처리될 수 있는 형태가 되며, 읽어들인 데이터는 프로그램에서 이용됩니다
4. 파일 닫기: 데이터를 모두 읽어들인 후에는, 파일을 닫아야 합니다. 파일을 닫으면, 해당 파일에 대한 운영체제의 자원이 반환됩니다

위와 같은 과정을 통해, 운영체제는 파일 시스템에서 파일을 읽어들이고, std::fstream 클래스는 내부적으로 데이터를 버퍼에 저장합니다. 이러한 구조는 파일 입출력 작업을 효율적으로 수행하기 위한 것입니다.

seekg

std::fstream 클래스는 파일 입출력 작업을 수행하기 위한 다양한 멤버 함수를 제공합니다. seekg 함수는 그 중 하나로, 파일 내에서 위치를 이동하는데 사용됩니다.

seekg 함수는 파일 포인터의 위치를 이동시킵니다. 파일 포인터는 파일에서 데이터를 읽어들이거나 쓰기 위해 사용되는 위치 정보를 담고 있는 변수입니다. seekg 함수를 이용하면, 파일 포인터를 파일 내의 원하는 위치로 이동시킬 수 있습니다.

seekg 함수는 다음과 같은 구조를 가집니다

std::fstream& seekg (streampos pos);
std::fstream& seekg (streamoff off, ios_base::seekdir way);

첫 번째 형식의 seekg 함수는, 파일 포인터를 지정된 위치로 이동시킵니다. pos 매개변수는 파일 내에서 이동시킬 위치를 나타내며, streampos 타입으로 지정됩니다.
두 번째 형식의 seekg 함수는, 상대적인 위치와 이동 방향을 이용하여 파일 포인터를 이동시킵니다. off 매개변수는 현재 위치에서 이동할 바이트 수를 나타내며, way 매개변수는 이동 방향을 나타내는 ios_base::seekdir 열거형 값 중 하나를 지정합니다.

예를 들어, seekg(10)은 파일 포인터를 파일의 10번째 위치로 이동시킵니다. seekg(-5, std::ios_base::cur)은 현재 파일 포인터 위치에서 5바이트 앞으로 이동시킵니다.

seekg 함수는 std::ios::cur (현재 위치), std::ios::beg (파일 시작 위치), std::ios::end (파일 끝 위치)와 같은 ios::seekdir 값으로 이동 방향을 지정할 수 있습니다. 이러한 방법을 이용하면 파일 포인터를 특정 위치가 아닌, 파일의 시작이나 끝 부분으로 이동시킬 수 있습니다.

아래는 seekg 함수의 사용 예제입니다. 예제에서는 파일에서 10바이트를 읽어들이기 위해, 파일 포인터를 파일의 10번째 위치로 이동시킨 후 데이터를 읽어들이는 방법을 보여줍니다

#include <fstream>
#include <iostream>

int main() {
    std::ifstream infile("data.txt", std::ios::in | std::ios::binary);

    if (!infile) {
        std::cerr << "Failed to open file." << std::endl;
        return 1;
    }

    // 파일 포인터를 10번째 위치로 이동시킴
    infile.seekg(10, std::ios::beg);

    char data[11] = {0};
    infile.read(data, 10);

    std::cout << "Data read from file: " << data << std::endl;

    infile.close();

    return 0;
}

위 예제에서, seekg 함수를 이용하여 파일 포인터를 10번째 위치로 이동시킨 후 read 함수를 이용하여 10바이트를 읽어들입니다. 이렇게 파일 포인터를 원하는 위치로 이동시켜 파일 내의 원하는 위치에서 데이터를 읽어들일 수 있습니다.

seekg(0, std::ios::end)는 파일 포인터를 파일의 끝 부분으로 이동시키는 역할을 합니다.

두 번째 인자인 std::ios::end는 이동 방향을 나타내며, 파일의 끝에서부터 이동하라는 의미입니다. 첫 번째 인자인 0은 파일 끝으로부터 0바이트 떨어진 위치로 이동하라는 의미이므로, 실제로는 파일의 끝 부분으로 파일 포인터가 이동됩니다.

이렇게 파일 포인터를 파일 끝 부분으로 이동시키면, 파일의 크기를 계산하거나 파일에 새로운 데이터를 추가할 때 유용합니다. 예를 들어, 파일의 크기를 계산하기 위해서는 파일 포인터를 끝 부분으로 이동시켜 파일의 위치를 알아내고, 그 값을 파일의 크기로 사용할 수 있습니다. 또한, 파일 끝에 새로운 데이터를 추가하기 위해서도 파일 포인터를 끝 부분으로 이동시켜야 합니다.

src.seekg(beg, std::ios::beg)는 파일 포인터를 파일의 시작 부분으로부터 beg 바이트 떨어진 위치로 이동시키는 역할을 합니다.

첫 번째 인자인 beg는 파일 포인터를 이동할 바이트 수를 나타내며, 두 번째 인자인 std::ios::beg는 이동 방향을 나타냅니다. std::ios::beg는 파일의 시작부터 이동하라는 의미입니다.

예를 들어, src.seekg(10, std::ios::beg)은 파일의 시작 부분으로부터 10바이트 떨어진 위치로 파일 포인터를 이동시킵니다. 이렇게 파일 포인터를 원하는 위치로 이동시켜 파일 내의 원하는 위치에서 데이터를 읽어들일 수 있습니다.

std::fstream src(frag, std::fstream::in); 
src.seekg(0, std::ios::end); 
src.seekg(beg, std::ios::beg);

위 코드는 파일을 열어서 파일 포인터를 파일의 끝으로 이동시킨 후, 다시 파일의 시작 부분으로부터 beg바이트 떨어진 위치로 파일 포인터를 이동시키는 역할을 합니다.
첫 번째 줄에서 std::fstream::in 모드로 파일을 열어서 src 객체를 생성합니다. 이때, 파일을 읽기 모드로 열기 때문에 파일 내용을 수정할 수 없고, 읽기만 가능합니다.
두 번째 줄에서 src.seekg(0, std::ios::end)를 호출하여 파일 포인터를 파일의 끝으로 이동시킵니다. 이렇게 파일 포인터를 파일의 끝으로 이동시키면, 파일의 크기를 계산하거나 파일에 새로운 데이터를 추가할 때 유용합니다.
세 번째 줄에서 src.seekg(beg, std::ios::beg)를 호출하여 파일 포인터를 파일의 시작 부분으로부터 beg바이트 떨어진 위치로 이동시킵니다. 이렇게 파일 포인터를 원하는 위치로 이동시켜서 파일 내의 원하는 위치에서 데이터를 읽어들일 수 있습니다.
즉, 이 코드는 파일에서 데이터를 읽어들이기 위해서 파일 포인터를 파일의 시작 부분으로부터 beg바이트 떨어진 위치로 이동시킨 후, 파일의 끝 부분에서부터 파일 포인터를 이동시켜 파일의 크기를 계산하는 방법을 사용합니다

~할 가능성이 높다 / 낮다 영어로

꼬북칩조아 — Fri, 31 Mar 2023 07:36:19 +0900

기본적으로는 가능성을 표현할 때는 문장에 "probably (not) " 를 적극적으로 활용할 것

A: 내일 비가 올 것 같아.
B: 그럴 가능성이 높겠지.
하지만 기상 예보에 따르면 오후에는 구름이 조금 걷히고 해가 떠올라서 그 전에 빨래를 널어놓는 것이 좋을 거야.
A: 그래, 그러면 내일 아침에 빨래를 하고 가야겠다.

A: It's probably going to rain tomorrow.
B: Yeah, it's quite likely. But according to the weather forecast,
there might be some clearing in the afternoon and the sun could come out,
so it's a good idea to hang your laundry out before then.
A: Okay, then I'll do my laundry in the morning tomorrow.

"빨래를 널다"는 "hang the laundry" 또는 "hang up the laundry"
"빨래를 걷다"는 "take down the laundry"

A: 이번 분기 실적은 어떻게 될까요?
B: 잘될 가능성이 높아 보입니다. 우리 회사는 새로운 제품 출시를 통해 시장에서 큰 인기를 얻었고,
경쟁사보다 좋은 가격으로 제공하고 있으니까요.
A: 그렇다면 재고 관리도 신경써야겠네요.
B: 맞아요. 재고가 떨어졌을 때 대비해서 미리 생산량을 늘리는 것이 좋겠어요.

A: How do you think our performance will be this quarter?
B: It's probably going to be good.
Our company has gained significant popularity in the market through the launch of new products
and offering them at better prices than our competitors.
A: Then, we should also pay attention to inventory management.
B: Right. It's a good idea to increase our production volume in advance to prepare for when our inventory runs low.

비교 표현
When comparing A to B, you'll find that B has this additioanl functionality
In contrast to A, B offers this particular feature
Compared to A, B boasts this particular function

~할 가능성이 높다: There's a good chance that + ~

이번 주말에 비가올 가능성이 높다

There is a good chance that it'll rain.(it's going to rain today)

조심하지 않으면 길을 잃을 가능성이 높아

There is a good chance we're goning to get lost if we ate not careful

걔한테 말하진 않았는데 이미 알고 있을 가능성이 높아

I haven't told him about this.There is a good chance that he already knows.

*good chance: '가능성'; 원어민들이 '좋은 기회'라고 이해하는 일은 없음 (반대의미로 가능성이 낮다라는 표현에 사용하진 않음)

A: 제가 그 프로젝트에 대한 계획을 아무도에게 말하지 않았는데, 그것을 이미 다른 사람들이 알고 있는 것 같아요.
B: 그렇다면 그것이 담당자인 Tom's bread and butter 중 하나인 것 같네요.
그는 회사 내에서 가장 알아봤을만한 사람 중 하나에요.
A: 그렇게 생각해 보니 맞아요.
비밀로 유지하려고 해왔고 그걸 말해서 불편한 분위기를 만들고 싶진 않지만, 어쩔 수 없이 그것을 언급해야 할 것 같아요.
B: 물론이죠. "Beat around the bush"하지 마시고 직설적으로 이야기해야죠.
그렇게 했을 때, 톰이 이미 알고 있다면, 그것을 인정하게 될 것입니다

A: There is a good chance that other people already know about my plans for the project,
even though I haven't told anyone ( it seems like other people already know about it)
B: Then, that might be one of Tom's bread and butter.
He's one of the most knowledgeable people in the company.
A: Come to think of it, you're right.
I've been trying to keep it a secret and not create a secretive atmosphere by mentioning it,
but I think I'll have to bring it up eventually.
B: Of course. Don't beat around the bush and be straightforward.
If Tom already knows, he'll acknowledge it when you mention it that way.

Tom's bread and butter : Tom 의 핵심 전문 분야 (Bread and butter"는 기본적이면서 중요한 것을 의미)
Beat around the bush : 어떤 주제나 문제를 직접적으로 다루지 않고, 우회적으로 말하거나 중얼거리는 것
Admit"은 "인정하다"라는 의미로, 주로 부정적인 것을 인정할 때 사용. 한편, "Acknowledge"는 "인정하다" 또는 "인사하다"라는 의미로, 양호한 것과 부정적인 것 모두를 포괄적으로 다룰 수 있음 (즉, "If Tom already knows, he'll admit it when you mention it that way."라고 하면, Tom이 이미 알고 있다는 것이 부정적인 것처럼 들릴 수 있 음, "acknowledge"를 사용하면 좀 더 중립적이고 양호한 뉘앙스)

~할 가능성이 높다/ 낮다 : (not) likely , It's likely that ~

Likely : 원래 문장에 섞어서 쓴다고 생각하면 됨

오늘 밤에는 차가 많이 막힐거야 ---> 오늘 밤에 차가 많이 막힐 가능성이 높아

☞ The traffic will be(is gonna) bad tonight

☞ The traffic is likely going to be bad tonight.

오늘 밤에는 차가 많이 막히지 않을 가능성이 높아

☞ The traffic is not likely going to be bad tonight.

It's likely that ~

나중에 걔는 생각을 바꿀 가능성이 높아

☞ Later, he is likely going to change his mind.

☞ It's likely that he'll change his mind later

내가 걔랑 얘기를 다시 해볼수는 있는데, 걔가 생각이 바뀔 가능성은 별로 없어

☞ I could try talking with him again, but he is not likely gonna change his mind

☞ I could try talking with him again, but it's not (very) likely that he'll change his mind

A: 휴가를 내기 위해 상사와 대화했어?
B: 응, 했는데. 다시 상사와 대화해볼 수는 있겠지만,
그는 마음을 바꿀 가능성은 낮을 거야. 바쁜 시즌에 휴가를 내는 걸 매우 엄격하게 다루거든.
A: 그렇구나. 그러면 인사팀에게 말해봐서 도움을 받을 수는 없을까?
B: 좋은 생각이야. 그걸로 한 번 시도해봐야겠어. 제안해줘서 고마워.

A: Did you talk to your boss about taking time off for vacation?
B: Yeah, I did. I could try talking with him again, but he's not likely gonna change his mind.
He's pretty strict when it comes to taking time off during the busy season.
A: I see. Well, maybe you could try talking to HR instead and see if they can help you out.
B: That's a good idea. I think I'll give that a try. Thanks for the suggestion.

예약 잡는게어려울거야 ---> 예약 잡는게 어려울 가능성이 높아

☞ It is going to be difficult(hard) to get a resevation.

☞ It is likely going to be difficult(hard) to get a resevation.

걔가 이미 알고있을 수 있는데 "그럴 가능성은 별로없어" (이때 likely 많이 쓰임 문장)

☞ He might already know, but it's(that's) not very likely

A: 네 남동생한테 서프라이즈 파티에 대해서 얘기했어?
B: 아니, 안 했어. 이미 알고 있을 수도 있지만, 그 가능성은 별로 높지 않아. 다른 사람이 그에게 말했을 것 같진 않아.
A: 정말이야? 걔 몰라도 되는 거 꽤 잘 알아채잖아
B: 알아, 그러나 내가 초대된 모두에게 아무것도 말하지 말라고 잘 알려줬어.
게다가, 걔 요즘 무슨 일이 일어나고 있는지 그렇게 관심을 많이 두고 있지 않은 것 같아.
A: 그렇구나, 네 판단을 믿지뭐. 그냥 파티 전까지 그가 발견하지 않기를 바라자
B: 응, 제발.

A: Did you tell your brother about the surprise party?
B: No, I didn't. He might already know, but that's not very likely.
I don't think anyone else would have told him.
A: Are you sure? He's pretty good at finding out things that he's not supposed to know.
B: I know, but I made sure that everyone who was invited knew not to say anything.
Plus, I don't think he's been paying much attention to what's been going on lately.
A: Okay, I trust your judgment. Let's just hope he doesn't find out before the party.
B: Yeah, fingers crossed!

I don't think anyone else would have told him. : 이 문장에서 "would"는 과거 시제의 의미로 사용
(과거의 예상된 상황을 나타냄 ; 즉, 과거의 상황에서 "그에게 말한 사람이 없었을 것"이라는 추측이나 가정)

I doubt that ~ : 성격은 좀 다름 . 가능성이 별로없다라고 할 때만 쓰임 (나의 판단)

다시 추워질 가능성은 없어 (뉘앙스: 다시 추워질 가능성은 낮다고 봐; 나의 판단)

☞ I doubt that it's going to get colder again

A: 이번 주말 날씨가 어떨까요?
B: "Under the weather" 일지도 몰라요.
몇 일 전까지 날씨가 점점 추워졌기 때문에, 이번 주말도 그렇게 추울 가능성이 높아 보입니다.
A: 그래도 최근에는 봄이 도착한 것 같은 기분이 들어요. 더 추워지기보다는 오히려 더워질 것 같아요.
제말은 저는 다시 추워질 가능성은 낮다고 봐요
B: "Break the ice"하고 싶긴 하지만, 저는 아직도 날씨가 추워질 것 같다고 생각해요.
예측은 항상 불확실하기 때문에 "Bundle up" 해서 감기 조심하는 게 좋겠어요.

A: What do you think the weather will be like this weekend?
B: It might be "under the weather".
Since the weather was getting colder until a few days ago, there's a good chance it'll be cold this weekend too.
A: Still, I feel like spring has arrived lately. I think it will get warmer rather than colder.
I mean I doubt that it's going to get colder again
B: I want to "break the ice" but I still think it's going to get colder.
Predictions are always uncertain, so it's better to "bundle up" and be careful not to catch a cold.

"Under the weather" : "건강이 좋지 않은, 몸상태가 안좋은"
ex) I'm feeling a bit under the weather today (오늘은 몸 상태가 좋지 않다)
"until a few days ago" : "몇 일 전까지는"(어떤 일이 어떤 시점까지 계속되었으나, 그 시점 이후에는 그렇지 않았음을 나타냄)
ex) I used to live in New York until a few years ago (몇 년 전까지는 뉴욕에 살았었다)
Rather than"은 "보다는"이라는 뜻으로, 둘 중 하나를 선택하는 것을 나타내며, 보통 두 가지 중 하나가 다른 것보다 더 확실하거나 우월하다는 것을 나타낼 때 사용
"Break the ice": "어색한 분위기를 해소하다"를 의미
이 문장에서는 날씨에 대한 예측이 다소 낙관적이지 않은 (상반되는 의견) 의견을 얘기하면서 한 말
ex) I always find it difficult to break the ice at parties (파티에서 어색한 분위기를 해소하기가 어려워요)
"Bundle up" : "따뜻하게 입고 겨울철 추위를 대비하다"(추운 날씨에 옷을 여러 겹 입는 것을 의미하며, 몸을 따뜻하게 감싸는 것)
ex) It's really cold outside, so make sure you bundle up before you go out (밖이 매우 춥기 때문에 나가기 전에 따뜻하게 입고 갈아입어야 해)

QNX - HAM, Pulse, Signal

꼬북칩조아 — Thu, 30 Mar 2023 17:01:22 +0900

HAM (High availablity manager)

QNX HAM은 QNX Software Systems에서 개발한 QNX Neutrino 운영 체제의 높은 가용성 모듈입니다.

특히, 시스템의 장애가 발생했을 때 자동으로 문제를 해결하고 서비스를 유지하는 데 도움을 줍니다.

RTOS는 임베디드 시스템에 사용되는 작고 경량화된 운영 체제로, 실시간 응용 프로그램의 요구 사항을 충족하는 데 필수적입니다.

그러나 이러한 시스템에서는 장애가 발생하면 시스템 전체 또는 일부 서비스가 중단될 수 있으며, 이는 치명적인 결과를 초래할 수 있습니다

HAM은 이러한 상황을 방지하기 위해 설계되었습니다.

HAM은 여러 노드 간의 서비스 가용성을 모니터링하고, 문제가 발생한 경우 이를 식별하고 대처하는 기능을 제공합니다.

예를 들어, HAM은 서비스를 실행하는 노드에서 문제가 발생한 경우 다른 노드로 서비스를 이전하거나, 문제가 발생한 노드를 다시 시작하거나, 대체 서비스를 시작할 수 있습니다

RTOS에서 HAM은 시스템의 가용성을 향상시키는 데 필수적입니다. 이를 통해 시스템의 안정성을 높이고, 장애 발생 시 복구 시간을 단축시킬 수 있습니다. 또한, HAM은 시스템 관리자가 서비스와 노드의 상태를 모니터링하고, 관리하는 데 도움을 줍니다

따라서 QNX HAM은 주로 두 대 이상의 컴퓨터 노드를 가진 클러스터 환경에서 사용됩니다.

즉, 주 서버와 백업 서버(예: 스탠바이 서버) 형태의 네트워크에서 에서 주 서버에 장애가 발생하면 HAM은 백업 서버가 주 서버의 역할을 대신 수행하도록 전환하는 것입니다.

예를 들어, 클러스터 환경에서 데이터베이스 서버가 실행 중이라고 가정해 보겠습니다.
이 데이터베이스 서버는 주 서버와 백업 서버 모두에서 실행됩니다.
HAM은 이 데이터베이스 서버를 모니터링하고, 데이터베이스 서버에 장애가 발생하면 백업 서버에서 데이터베이스 서버의 역할을 수행하도록 전환합니다.
데이터베이스 서버가 실행 중인 동안 HAM은 주 서버와 백업 서버 간의 통신을 유지합니다.
이를 위해 HAM은 각 노드의 상태를 모니터링하고, 데이터베이스 서버의 상태를 주기적으로 확인합니다.
데이터베이스 서버에서 장애가 발생하면 HAM은 이를 감지하고, 백업 서버에 데이터베이스 서버의 역할을 전환합니다.
전환 프로세스는 다음과 같은 단계를 거칩니다.

1. HAM은 백업 서버에 데이터베이스 서버의 복제본을 만듭니다.
2. HAM은 백업 서버에서 데이터베이스 서버의 역할을 시작하도록 구성합니다.
3. HAM은 주 서버에서 데이터베이스 서버의 역할을 중지합니다.

이러한 과정을 통해 HAM은 데이터베이스 서버의 가용성을 유지하며, 클러스터 환경에서 높은 가용성을 보장합니다.

HAM은 클러스터 내에서 동작하는 모든 노드가 상호작용하도록 관리합니다.

이를 위해 HAM은 클러스터 노드 간의 통신을 유지하고, 각 노드의 상태를 모니터링하며, 필요한 경우 백업 서버로의 전환을 관리합니다

QNX HAM은 높은 가용성을 유지하기 위해 여러 가지 기술을 사용합니다.

예를 들어, HAM은 특정 서비스(예: 데이터베이스 또는 웹 서버)가 중단될 경우 해당 서비스를 다시 시작하도록 구성할 수 있습니다.

또한 HAM은 노드 간의 자동 재구성, 로드 밸런싱 및 클러스터 구성 관리를 지원합니다

QNX HAM은 다양한 산업 분야에서 사용됩니다.

예를 들어, 통신, 자동차, 의료 및 방위 산업에서 클러스터 환경에서 높은 가용성을 필요로 하는 애플리케이션을 지원하기 위해 사용됩니다

다음은 C++ 기반 ham 을 활용하는 예제 코드입니다.

#include <iostream>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/neutrino.h>
#include <sys/syspage.h>
#include <ha/ham.h>

#define MY_SERV_NAME "MyService"

int main(int argc, char *argv[]) {
    // HAM 연결
    HAM_HANDLE_T ham_handle;
    if (ham_connect(&ham_handle) != EOK) {
        std::cerr << "Failed to connect to HAM\n";
        return EXIT_FAILURE;
    }
    
    // MyService 서비스 검색
    HAM_SERVICE_T *service;
    if (ham_find_service(ham_handle, MY_SERV_NAME, 0, &service) != EOK) {
        std::cerr << "Failed to find MyService\n";
        ham_disconnect(ham_handle);
        return EXIT_FAILURE;
    }
    
    // SIGTERM 시그널 핸들러 등록
    signal(SIGTERM, [](int sig) {
        ham_disconnect(ham_handle);
        exit(EXIT_SUCCESS);
    });
    
    // MyService 서비스 모니터링
    while (true) {
        // MyService 서비스 상태 확인
        HAM_STATE_T state;
        if (ham_get_service_state(service, &state) != EOK) {
            std::cerr << "Failed to get MyService state\n";
            ham_disconnect(ham_handle);
            return EXIT_FAILURE;
        }
        
        std::cout << "MyService state: " << state << "\n";
        
        sleep(1);
    }
    
    // HAM 연결 해제
    ham_disconnect(ham_handle);
    
    return EXIT_SUCCESS;
}

먼저, ham_connect() 함수를 사용하여 HAM과 연결합니다.
그리고 ham_find_service() 함수를 사용하여 MyService 서비스를 검색합니다.
이후 while문 안에서 ham_get_service_state() 함수를 사용하여 MyService 서비스의 상태를 주기적으로 확인합니다.
SIGTERM 시그널이 발생하면 HAM과의 연결을 해제하고 프로그램을 종료합니다.

pulse

QNX에서 pulse는 시스템에서 발생하는 이벤트를 동기적으로 처리하기 위한 방법 중 하나입니다.

Pulse는 두 개의 컴포넌트 간에 메시지를 교환하는 방법 중 하나이며, 높은 우선순위를 가지는 이벤트에 대한 처리를 보장합니다

pulse를 이용하여 시스템에서 발생하는 이벤트를 처리할 수 있습니다.

예를 들어, 자동차 제어 시스템에서는 속도, 방향, 브레이크 등의 상태가 변화할 때마다 pulse를 이용하여 이벤트를 처리합니다.

이를 통해 자동차의 상태 변화를 실시간으로 반영할 수 있습니다

다음은 C++에서 pulse를 이용하여 이벤트를 처리하는 예제입니다

#include <sys/neutrino.h>
#include <iostream>

int main() {
    // pulse 생성
    int chid = ChannelCreate(0);
    struct _pulse pulse;

    // 이벤트 발생
    int code = 0;
    int value = 1;
    MsgSendPulse(chid, getpid(), code, value);

    // 이벤트 처리
    int rcvid = MsgReceivePulse(chid, &pulse, sizeof(pulse), NULL);
    if (rcvid == -1) {
        std::cerr << "Error receiving pulse" << std::endl;
        return 1;
    }

    std::cout << "Received pulse: code=" << pulse.code << ", value=" << pulse.value.sival_int << std::endl;

    // pulse 삭제
    ChannelDestroy(chid);

    return 0;
}

이 예제는 ChannelCreate 함수를 이용하여 pulse를 생성하고, MsgSendPulse 함수를 이용하여 이벤트를 발생시킵니다.
이후, MsgReceivePulse 함수를 이용하여 이벤트를 처리합니다. 이때, pulse에 저장된 정보를 이용하여 이벤트를 처리할 수 있습니다.
pulse는 이외에도 다양한 용도로 사용될 수 있으며, 높은 우선순위를 가지는 이벤트 처리에 특히 유용합니다

Signal

QNX에서 signal은 프로세스 간에 비동기적으로 이벤트를 전달하기 위한 방법 중 하나입니다.

Signal은 각각의 시그널 번호를 가지며, 시스템에서 발생하는 이벤트를 처리하기 위해 사용됩니다.

QNX에서 signal은 kill() 함수를 이용하여 다른 프로세스에 전송할 수 있습니다.

이 때, 시그널 번호와 함께 전송되며, 이를 이용하여 대상 프로세스에서 해당 이벤트를 처리할 수 있습니다

다음은 C++에서 signal을 이용하여 이벤트를 처리하는 예제입니다.

#include <signal.h>
#include <unistd.h>
#include <iostream>

void signalHandler(int signum) {
    std::cout << "Received signal: " << signum << std::endl;
}

int main() {
    // 시그널 핸들러 등록
    signal(SIGUSR1, signalHandler);

    // 시그널 전송
    pid_t pid = getpid();
    int sig = SIGUSR1;
    int ret = kill(pid, sig);
    if (ret == -1) {
        std::cerr << "Error sending signal" << std::endl;
        return 1;
    }

    // 이벤트 처리
    // ...

    return 0;
}

이 예제는 signal 함수를 이용하여 시그널 핸들러를 등록하고, kill 함수를 이용하여 시그널을 전송합니다.
이후, 시그널 핸들러에서 해당 이벤트를 처리할 수 있습니다.
signal은 다양한 용도로 사용될 수 있으며, 주로 시스템에서 발생하는 이벤트를 처리하기 위해 사용됩니다.
예를 들어, 프로세스 간 통신에서는 signal을 이용하여 이벤트를 전송하고, 해당 이벤트를 처리하는 방식으로 구현됩니다

버퍼(buffer)와 표준입력 스트림(stream) 그리고 getch 와 getchar

꼬북칩조아 — Thu, 30 Mar 2023 16:19:15 +0900

버퍼(Buffer)

입력 버퍼는 사용자가 키보드나 마우스를 통해 입력한 데이터를 임시적으로 저장하는 메모리 공간입니다.

일반적으로 입력 버퍼는 FIFO(First-In-First-Out) 방식으로 동작합니다.

사용자가 키를 누르면 해당 키의 입력 데이터가 입력 버퍼의 맨 뒤에 추가됩니다.

그리고 프로그램에서 입력 함수를 호출할 때마다, 입력 버퍼의 가장 앞에 있는 데이터가 제거되며, 이 데이터를 함수가 반환합니다.

입력 버퍼는 보통 운영체제에서 관리되며, 이를 통해 여러 개의 프로그램이 동시에 입력을 처리할 수 있습니다. 입력 버퍼는 입력 함수를 호출하기 전까지는 입력 데이터를 저장하기 위한 임시적인 저장소일 뿐입니다. 따라서 입력 함수를 호출하면 입력 버퍼에서 데이터가 제거되므로, 같은 데이터를 두 번 이상 읽을 수 없습니다.

예를 들어, 사용자가 "Hello"라는 문자열을 입력하고, 프로그램에서 입력 함수를 두 번 호출하는 경우를 생각해보겠습니다

#include <iostream>
using namespace std;

int main() {
    char ch1, ch2, ch3, ch4, ch5;
    ch1 = getchar();
    ch2 = getchar();
    ch3 = getchar();
    ch4 = getchar();
    ch5 = getchar();

    cout << "입력한 문자: " << ch1 << ch2 << ch3 << ch4 << ch5 << endl;
    return 0;
}

위 예제 코드에서 사용자가 "Hello"를 입력하면, 입력 버퍼에는 "H", "e", "l", "l", "o", '\n'이 저장됩니다.
이후 getchar() 함수를 다섯 번 호출하면, 입력 버퍼에서 맨 앞에 있는 데이터가 제거되며, 이를 함수가 반환합니다.
따라서, 위 예제 코드에서 출력되는 문자열은 "Hello\n"이 됩니다.
즉, 입력 버퍼는 프로그램이 입력 데이터를 효율적으로 처리할 수 있도록 하는 운영체제의 기능으로,
입력 함수를 호출할 때마다 데이터를 반환하고, 버퍼에서 제거합니다.

입력 버퍼는 운영체제에서 제공하는 메모리 공간 중 하나로, 일반적으로 커널 내부의 메모리 영역에 위치합니다.

(따라서 프로그램에서는 입력 버퍼에 직접적으로 접근할 수 없습니다)

운영체제는 표준 입력 스트림에서 데이터를 읽어들이고, 이를 입력 버퍼에 저장합니다.

이후 입력 함수가 호출되면, 입력 버퍼에서 데이터를 읽어들이고, 함수가 반환됩니다.

입력 버퍼는 보통 운영체제에서 관리되며, 프로그램에서는 이를 직접적으로 조작할 수 없습니다.

대신, 프로그램은 입력 함수를 호출하여 입력 버퍼에서 데이터를 읽어들입니다.

입력 버퍼의 크기는 운영체제나 터미널의 설정에 따라 다르며, 이를 조절할 수 있는 경우도 있습니다.

일반적으로 입력 버퍼의 크기는 몇 바이트에서 몇 킬로바이트까지 가능합니다

입력 버퍼의 크기는 일반적으로 정적으로 결정됩니다.
즉, 프로그램이 실행될 때 버퍼의 크기가 결정되고, 이후에는 변경되지 않습니다.
이는 대부분의 운영체제에서 버퍼의 크기가 고정되어 있기 때문입니다.
버퍼의 크기는 운영체제나 터미널의 설정에 따라 다르며, 보통 수십바이트에서 수천바이트까지 가능합니다.
이 값은 보통 프로그램에서 변경할 수 없으며, 운영체제나 터미널 설정을 변경하여 버퍼의 크기를 조절할 수 있습니다.
또한, 동적으로 버퍼의 크기를 조절하는 방법도 있습니다.
이 경우에는 프로그램에서 직접적으로 버퍼를 관리하여 크기를 조절할 수 있으며, 이를 위해서는 동적 메모리 할당 함수인 malloc, realloc, free 등을 이용하여 메모리를 할당하고 해제해야 합니다.
그러나 이 방법은 일반적으로 복잡하고 오버헤드가 크므로, 버퍼 크기를 미리 결정하는 것이 일반적입니다

버퍼와 사용자 메모리

입력 함수가 호출되면, 입력 버퍼에 저장된 데이터를 가져와서 스택이나 힙 영역에 저장할 수 있습니다.

이 때, 입력 함수가 반환하는 값은 입력 버퍼에서 가져온 데이터가 저장된 위치를 나타내는 포인터입니다.

프로그래머는 이 포인터를 이용하여 가져온 데이터를 변수나 배열에 저장할 수 있습니다

예를 들어, C++에서 std::cin을 이용하여 입력을 받는 경우, 입력 버퍼에 저장된 데이터를 가져와서 std::string이나 char 배열 등의 변수에 저장할 수 있습니다. 이 때, std::cin 함수는 입력 버퍼에서 가져온 데이터가 저장된 위치를 나타내는 포인터를 반환하며, 이를 이용하여 변수에 데이터를 저장합니다

표준 입력 스트림(standard input stream)
표준 입력 스트림은 키보드나 파일 등의 입력 소스에서 데이터를 읽어오는 C++ 표준 라이브러리의 입력 스트림 객체입니다.
표준 입력 스트림은 std::cin 객체를 통해 사용할 수 있으며, >> 연산자를 이용하여 데이터를 읽어올 수 있습니다.
예를 들어, int형 변수에 값을 입력받는 코드는 다음과 같습니다.

int num;
std::cin >> num;

표준 입력 스트림은 프로그램에서 입력을 받는 가장 일반적인 방법입니다.
키보드로부터 데이터를 입력받는 경우에는 표준 입력 스트림이 사용되며,
파일로부터 데이터를 입력받는 경우에도 표준 입력 스트림을 이용하여 파일의 내용을 읽어올 수 있습니다.

std::cin

std::cin은 C++ 표준 라이브러리에서 제공하는 입력 스트림 객체 중 하나로, 표준 입력(standard input)으로부터 데이터를 읽어옵니다. std::cin은 iostream 헤더 파일에 정의되어 있으며,아래와 같이 동작합니다.

1. 키보드나 파일 등의 입력 소스에서 데이터를 읽어옵니다. 이때, 키보드로부터 데이터를 입력받는 경우에는 사용자가 Enter 키를 입력할 때까지 입력을 받습니다

2. 입력된 데이터를 입력 버퍼(input buffer)에 저장합니다

3. 프로그램에서 std::cin 객체를 이용하여 데이터를 읽어오는 경우, 입력 버퍼에서 데이터를 읽어옵니다

4. 읽어온 데이터를 변수에 저장합니다. 이때, >> 연산자를 이용하여 데이터를 읽어옵니다.

>> 연산자는 입력 버퍼에서 공백(space), 탭(tab), 개행(newline) 등을 구분자로 사용하여 데이터를 분리합니다

std::cin은 입력 버퍼에 데이터가 있으면 즉시 데이터를 읽어옵니다.

따라서, std::cin을 이용하여 입력을 받을 때에는 입력 버퍼가 비어있는지 확인하는 것이 중요합니다.

입력 버퍼가 비어있지 않은 상태에서 std::cin을 이용하여 데이터를 읽어오면, 입력 버퍼에 남아있는 데이터를 읽어올 수 있습니다.

이를 방지하기 위해서는 std::cin을 이용하여 데이터를 읽어오기 전에 입력 버퍼를 비워주는 작업이 필요합니다

예를 들어, 다음과 같은 코드는 사용자로부터 정수를 입력받고, 입력된 값을 출력합니다.

#include <iostream>

int main() {
    int num;
    std::cin >> num;
    std::cout << "입력된 값: " << num << std::endl;
    return 0;
}

이 코드는 std::cin을 이용하여 사용자로부터 정수를 입력받은 후, 입력된 값을 출력합니다.

>> 연산자를 이용하여 데이터를 읽어올 때, 입력 버퍼에 데이터가 없는 경우에는 사용자의 입력을 기다리며,

입력 버퍼에 데이터가 있는 경우에는 바로 데이터를 읽어옵니다

getch

C++에서 콘솔 입력을 받을 때 버퍼를 이용하지 않고 바로 입력을 받는 방법으로는 "getch()" 함수를 사용하는 방법이 있습니다.

getch()" 함수는 conio.h 헤더 파일에 정의되어 있으며, 키보드 입력을 즉시 받아서 처리합니다. 이 함수는 키 입력을 받으면 바로 반환하므로 버퍼를 사용하지 않습니다

다음은 "getch()" 함수를 사용하여 콘솔에서 한 글자를 입력받는 예제 코드입니다.

#include <iostream>
#include <conio.h>

using namespace std;

int main() {
    char ch = getch();
    cout << "입력한 문자: " << ch << endl;
    return 0;
}

위 예제 코드에서 getch() 함수는 사용자로부터 한 글자를 입력받고, 그 결과를 변수 ch에 저장합니다.
그리고 저장된 값을 출력합니다. 이렇게 하면 입력 버퍼를 사용하지 않고 즉시 입력을 받을 수 있습니다.

getchar

"getchar()" 함수는 stdio.h 헤더 파일에 정의되어 있으며, 표준 입력 스트림에서 한 글자를 읽어서 처리합니다. 이 함수는 버퍼를 사용하지 않으므로 입력을 받을 때마다 바로 처리할 수 있습니다.

다음은 "getchar()" 함수를 사용하여 콘솔에서 한 글자를 입력받는 예제 코드입니다.

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    char ch = getchar();
    cout << "입력한 문자: " << ch << endl;
    return 0;
}

위 예제 코드에서 getchar() 함수는 표준 입력 스트림에서 한 글자를 읽어서 변수 ch에 저장합니다.
그리고 저장된 값을 출력합니다. 이렇게 하면 입력 버퍼를 사용하지 않고 즉시 입력을 받을 수 있습니다

C++에서 콘솔 입력을 받을 때 버퍼를 사용하지 않는 또 다른 방법으로는 "getchar_unlocked()" 함수를 사용하는 방법이 있습니다

"getchar_unlocked()" 함수는 getchar() 함수와 비슷하지만, 내부적으로 동기화를 수행하지 않아서 더 빠르게 입력을 받을 수 있습니다. 이 함수는 일반적으로 멀티스레드 환경에서 사용되지 않으며, 동기화가 필요하지 않은 단일 스레드 환경에서 사용됩니다

다음은 "getchar_unlocked()" 함수를 사용하여 콘솔에서 한 글자를 입력받는 예제 코드입니다.

#include <iostream>
#include <cstdio>

using namespace std;

inline char read_char() {
    char c = getchar_unlocked();
    while (c == ' ' || c == '\n' || c == '\r') {
        c = getchar_unlocked();
    }
    return c;
}

int main() {
    char ch = read_char();
    cout << "입력한 문자: " << ch << endl;
    return 0;
}

위 예제 코드에서 read_char() 함수는 getchar_unlocked() 함수를 사용하여 한 글자를 읽어서 처리합니다. 이 함수는 입력 버퍼를 사용하지 않으므로 더 빠르게 입력을 처리할 수 있습니다. 함수 내부에서는 입력 받은 값이 공백 문자(' '), 개행 문자('\n'), 혹은 캐리지 리턴('\r')인 경우에는 다시 입력을 받도록 처리합니다.

getch()와 getchar() 차이

getch()와 getchar() 함수는 모두 콘솔에서 입력을 받는 함수입니다. 그러나 두 함수에는 몇 가지 차이가 있습니다.

1. 헤더파일

getch() 함수는 conio.h 헤더 파일에 정의되어 있고, getchar() 함수는 stdio.h 헤더 파일에 정의되어 있습니다

2. 입력 대기 방식

getch() 함수는 사용자가 키를 누르는 즉시 바로 입력을 받아들입니다. 이에 반해 getchar() 함수는 사용자가 입력을 마치고 Enter 키를 누르면 입력을 받아들입니다

3. 입력 처리 방식

getch() 함수는 입력 받은 키 값을 즉시 반환합니다. 이에 반해 getchar() 함수는 표준 입력 스트림에서 한 글자를 읽어서 반환합니다

4. 입력 처리 대상

getch() 함수는 콘솔에서 키 입력만을 받아들입니다.

이에 반해 getchar() 함수는 콘솔에서 뿐만 아니라 파일 등에서도 입력을 받아들일 수 있습니다

따라서, getch() 함수는 사용자가 키 입력을 바로 반영하여 빠른 입력 처리가 필요한 경우에 사용되며, getchar() 함수는 문자열 입력을 받아야 하는 경우나, 파일에서 입력을 받아들여야 하는 경우에 사용됩니다

getchar() 함수는 표준 입력 스트림에서 한 글자씩 읽어들입니다. 때문에 두 글자 이상을 입력하고 Enter 키를 누르면 첫 번째 글자만 읽어들이고, 두 번째 글자는 입력 버퍼에 남게 됩니다. 그리고 Enter 키는 새로운 줄 문자('\n')으로 인식되어 입력 버퍼에 추가됩니다.

이후 getchar() 함수를 다시 호출하면 입력 버퍼에 있는 다음 글자를 읽어들이게 됩니다. 만약 입력 버퍼에 다음 글자가 없다면, getchar() 함수는 입력 대기 상태가 됩니다

따라서, getchar() 함수를 두 번 호출하면 두 글자 이상의 입력을 받을 수 있습니다. 다음은 이에 대한 예제 코드입니다

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    char ch1 = getchar();
    char ch2 = getchar();
    cout << "입력한 문자: " << ch1 << ch2 << endl;
    return 0;
}

위 예제 코드에서 첫 번째 getchar() 함수는 입력 버퍼에서 한 글자를 읽어들이고, 두 번째 getchar() 함수는 다음 글자를 읽어들입니다. 그리고 두 글자를 모두 출력합니다.

const char* 와 string class

꼬북칩조아 — Thu, 30 Mar 2023 07:53:04 +0900

const char* : C-style 문자열을 나타내는 포인터

여기서 C-styel 문자열이란, 말그대로 C 언어에서 사용하는 문자열 표현 방식으로, Null 종료 문자열(Null-terminated string)을 사용하여 문자열을 표현합니다.

Null 종료 문자열은 문자열의 끝에 항상 널 문자('\0')가 포함된 문자열을 의미합니다.

예를 들어, "Hello"라는 문자열은 다음과 같이 C-style 문자열로 표현할 수 있습니다.

char str[] = {'H', 'e', 'l', 'l', 'o', '\0'};

이렇게 문자열을 표현할 경우 문자열의 끝을 알기 위해 널 문자('\0')을 사용합니다.
이를 이용해 문자열의 길이를 계산하거나, 문자열을 다루는 다양한 함수를 사용할 수 있습니다.

다음은 C-style 문자열에서 자주 사용되는 함수들입니다 (c++에서 사용할 경우, <cstring> 헤더 include 필요)

1. strlen() : 문자열 길이 계산

const char* str = "Hello, world!";
int length = strlen(str); // 13

*공백, 특수문자(, !) 등도 포함. null 은 미포함.

2. strcpy() : 문자열 복사

char src[] = "Hello";
char dest[10];
strcpy(dest, src);
// dest는 "Hello"로 설정됩니다.

3. strcat() : 문자열 연결

char str1[20] = "Hello";
char str2[20] = "World";
strcat(str1, str2);
// str1은 "HelloWorld"로 설정됩니다.

4. strcmp() : 두 문자열 비교

char str1[] = "Hello";
char str2[] = "World";
int result = strcmp(str1, str2); // 음수 값이 반환됩니다.

5. strchr() : 문자열에서 특정 문자 검색

const char* str = "Hello, world!";
char ch = 'o';
const char* ptr = strchr(str, ch); // "o, world!"

6. strstr() : 특정 문자열 검색

const char* str = "Hello, world!";
const char* sub_str = "world";
const char* ptr = strstr(str, sub_str); // "world!"

C-style 문자열은 char 배열 형태로 표현됩니다.

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

int main() {
    char str1[20] = "Hello";
    char str2[] = ", world!";
    strcat(str1, str2);
    printf("%s\n", str1);

    char str3[20];
    strncpy(str3, str1 + 7, 5);
    printf("%s\n", str3);

    int result = strcmp(str1, str2);
    printf("%d\n", result);

    char* ptr = strstr(str1, "world");
    if (ptr != NULL) {
        strncpy(ptr, "Earth", 5);
    }
    printf("%s\n", str1);

    return 0;
}

위 예제에서는 strcat(), strncpy(), strcmp(), strstr() 등의 함수를 사용하여 C-style 문자열을 배열로 표현하고 조작합니다.
strcat(str1, str2) : str1 끝에 str2를 이어 붙입니다.
strncpy(str3, str1 + 7, 5) : str1의 8번째 문자부터 5개의 문자를 str3에 복사합니다.
strcmp(str1, str2) : str1과 str2를 비교합니다.
strstr(str1, "world") : str1에서 "world" 문자열을 찾습니다.
strncpy(ptr, "Earth", 5) : ptr에서 시작하는 위치에 "Earth" 문자열의 5개 문자를 복사합니다.
그러면 str1에는 "Hello, world!"가 저장되어 있을 것입니다.
strcat() 함수를 사용하여 ", world!" 문자열을 이어 붙여 "Hello, world!"를 완성합니다.
그 다음 strncpy() 함수를 사용하여 str1에서 8번째 문자부터 5개의 문자를 str3에 복사하고,
strcmp() 함수를 사용하여 str1과 str2를 비교합니다.
마지막으로 strstr() 함수를 사용하여 str1에서 "world" 문자열을 찾고, strncpy() 함수를 사용하여 "Earth" 문자열로 대체합니다.

출력결과

Hello, world!
world
72
Hello, Earth!

이 때, 문자열의 크기를 지정하지 않아도 되며, 필요에 따라 문자열의 길이를 동적으로 할당할 수 있습니다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char* str = NULL;
    size_t len = 0;
    ssize_t read;

    printf("Enter a string: ");
    read = getline(&str, &len, stdin);

    if (read == -1) {
        printf("Error reading input\n");
        return 1;
    }

    printf("Input string: %s\n", str);

    char* str2 = (char*)malloc(strlen(str) + 1);
    strcpy(str2, str);
    printf("Copied string: %s\n", str2);

    free(str);
    free(str2);

    return 0;
}

위 예제에서는 getline() 함수를 사용하여 키보드로부터 입력을 받습니다.
입력된 문자열의 길이에 따라 필요한 만큼 메모리를 동적으로 할당합니다.
그 다음, strcpy() 함수를 사용하여 할당된 메모리에 문자열을 복사합니다.
getline() 함수는 입력된 문자열의 길이와 할당된 메모리의 크기를 반환합니다.
malloc() 함수를 사용하여 문자열의 길이에 따라 필요한 만큼 메모리를 동적으로 할당합니다.
할당된 메모리에 strcpy() 함수를 사용하여 문자열을 복사합니다.
마지막으로 free() 함수를 사용하여 할당된 메모리를 해제합니다.

출력결과

Enter a string: Hello, world!
Input string: Hello, world!
Copied string: Hello, world!

C-style 문자열은 C++에서도 사용할 수 있습니다

(다만, C++에서는 문자열을 다루기 위해 string 클래스를 사용하는 것이 더 안전하고 편리합니다)

*(참고) getline

getline() 함수는 C++의 표준 라이브러리인 <iostream> 헤더 파일에 선언된 함수로,

파일 스트림 또는 입력 스트림에서 한 줄씩 문자열을 읽어올 때 사용됩니다.

getline() 함수는 기본적으로 세 개의 매개변수를 받습니다.

getline(std::istream& input_stream, std::string& str, char delimiter='\n');

input_stream: 입력 스트림 또는 파일 스트림 객체입니다. std::cin, std::ifstream 등이 될 수 있습니다.
str: 읽어온 문자열이 저장될 std::string 객체입니다.
delimiter: 읽어올 문자열의 끝을 표시하는 구분자입니다. 기본값은 개행 문자('\n')입니다.

getline() 함수는 입력 스트림에서 delimiter 문자를 만나거나 스트림의 끝에 도달할 때까지 문자열을 읽어 str 객체에 저장합니다.
이 때, delimiter 문자는 입력 스트림에서 제거되지 않고 버퍼에 남게 됩니다.

getline() 함수를 사용하면 키보드나 파일 등에서 한 줄씩 문자열을 읽어와 처리할 수 있습니다. getline() 함수를 이용하면, 사용자가 입력한 문자열을 std::string 객체에 저장할 수 있으며, 입력 스트림을 더 이상 읽지 않을 때까지 문자열을 계속해서 읽어올 수 있습니다.

string : 문자열을 다루기 위해 사용하는 c++ 표준 라이브러리 클래스

string은 문자열을 동적으로 할당하여 저장하고, 문자열의 길이 정보도 함께 저장합니다.

문자열을 수정하거나 추가하는 작업이 자유롭기 때문에 보다 편리하게 문자열을 다룰 수 있습니다.

또한, string 클래스는 C++ 표준 라이브러리의 일부로 제공되기 때문에 라이브러리에서 제공하는 다양한 기능을 사용할 수 있습니다.

std::string 클래스의 내부 구현은 크게 두 가지로 나눌 수 있습니다.

첫 번째는 문자열 데이터를 저장하기 위한 메모리 관리를 위한 부분이며,

두 번째는 문자열을 조작하기 위한 멤버 함수들을 구현하는 부분입니다.

첫 번째 부분에서는 문자열 데이터를 저장하기 위한 메모리를 할당하고, 필요에 따라 재할당합니다.

문자열 데이터는 동적으로 할당된 메모리 공간에 저장됩니다.

std::string 클래스는 문자열 데이터의 길이와 할당된 메모리 공간의 크기를 구별하며, 이를 통해 문자열 데이터를 조작할 때 메모리를 효율적으로 사용합니다.

두 번째 부분에서는 문자열을 조작하기 위한 멤버 함수들이 구현됩니다.

이러한 멤버 함수들은 문자열 데이터에 직접 접근하지 않고, 문자열 데이터에 대한 포인터와 길이 정보를 사용합니다.

이를 통해 문자열을 조작하는 과정에서 문자열 데이터의 내부 구조가 변경되더라도 멤버 함수들이 제대로 동작할 수 있습니다.

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, world!";

    // 문자열 데이터에 접근하는 방법
    const char* data = str.data(); // C-style 문자열로 변환된 데이터 포인터 반환
    std::cout << "Data: " << data << std::endl;

    // 문자열 데이터의 길이를 구하는 방법
    size_t length = str.length();
    std::cout << "Length: " << length << std::endl;

    // 문자열 데이터를 조작하는 방법
    str += " Welcome to the world!";
    std::cout << "Modified string: " << str << std::endl;

    return 0;
}

이 예제 코드에서는 std::string 클래스의 객체를 생성하고, 이를 통해 문자열 데이터를 다루는 방법을 보여줍니다.
먼저, 문자열 데이터에 접근하는 방법은 data라는 std::strring 클래스 멤버함수를 통해 할 수 있습니다.
data() 멤버 함수를 통해 내부 문자열 데이터의 C-style 문자열 형태로 변환된 데이터 포인터를 반환합니다.
이 포인터를 이용하면 std::string 클래스가 제공하지 않는 C-style 문자열 함수를 사용할 수 있습니다.

문자열 데이터의 길이를 구하는 방법 또한 std::string 클래스 멤버함수인 length() 통해 구할 수 있습니다.

단, 이 함수는 문자열 데이터가 저장된 메모리의 크기와는 다릅니다.

std::string 클래스는 문자열 데이터의 길이와 할당된 메모리 공간의 크기를 구별하여 문자열을 효율적으로 처리합니다.

std::string 클래스의 멤버 함수인 length()는 문자열의 길이를 반환합니다.
이 길이는 문자열 데이터에 포함된 실제 문자 개수를 의미합니다.
하지만 문자열 데이터가 메모리에 저장되는 방식 때문에, 문자열 길이와 실제 메모리 크기는 일치하지 않을 수 있습니다.
std::string 클래스는 동적으로 문자열 데이터를 할당하고 관리합니다.
이 때, 문자열 데이터는 null 종료 문자('\0')로 끝나야 합니다. 따라서 문자열 데이터를 저장하는 메모리 공간의 크기는 문자열 길이보다 1 큽니다. 예를 들어, "hello" 문자열의 경우 길이는 5이지만, 이 문자열을 저장하는 메모리 공간의 크기는 6입니다.
또한, std::string 클래스는 문자열 데이터를 저장하기 위해 동적으로 메모리를 할당합니다.
이 때, 할당되는 메모리의 크기는 문자열 데이터의 길이와는 관련이 없을 수 있습니다.
예를 들어, "hello" 문자열을 저장하기 위해 할당된 메모리 공간이 8바이트인 경우가 있습니다.
이는 메모리 할당의 내부 알고리즘에 따라 달라질 수 있습니다.
따라서, std::string 클래스의 length() 멤버 함수로 얻는 문자열 길이와 실제 문자열 데이터가 저장된 메모리 크기는 일치하지 않을 수 있습니다.
하지만, std::string 클래스는 문자열 데이터의 길이와 메모리 크기를 투명하게 관리하기 때문에, 사용자는 이러한 내부 구현 상세를 신경쓰지 않고 문자열을 처리할 수 있습니다

다양한 멤버 함수를 제공하여 문자열 데이터를 조작할 수 있는데, 이 예제에서는 += 연산자를 사용하여 문자열 데이터를 뒤에 추가하는 것을 구현 했습니다. 물론 이 외에도 append(), replace(), insert() 등 다양한 멤버 함수를 사용할 수 있습니다.

이러한 방식으로 std::string 클래스는 문자열 데이터를 동적으로 할당하고, 문자열을 조작하는 다양한 멤버 함수들을 제공합니다.

내부적으로는 문자열 데이터를 저장하기 위한 메모리 관리와 문자열 조작 함수들의 구현 등이 이루어지며, 이를 통해 문자열 데이터를 효율적으로 처리할 수 있습니다.

아래는 string 멤버함수를 활용하여 문자열 데이터를 처리하는 예제입니다.

(문자열을 분리하여 벡터에 저장하고, 저장된 문자열을 역순으로 출력하는 기능 구현)

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::string str = "apple,banana,cherry,date,elderberry";

    // 문자열을 구분자로 분리하여 벡터에 저장하는 방법
    std::vector<std::string> vec;
    size_t start = 0, end = 0;
    while ((end = str.find(',', start)) != std::string::npos) {
        vec.push_back(str.substr(start, end - start));
        start = end + 1;
    }
    vec.push_back(str.substr(start));

    // 저장된 문자열을 역순으로 출력하는 방법
    for (auto iter = vec.rbegin(); iter != vec.rend(); ++iter) {
        std::cout << *iter << std::endl;
    }

    return 0;
}

std::string 클래스의 멤버 함수인 find()과 substr()을 활용하여 문자열을 분리하고, 이를 std::vector 컨테이너에 저장합니다.
이후 저장된 문자열을 역순으로 출력합니다.
1) 문자열을 구분자(' , ')로 분리하여 벡터에 저장
문자열에서 , 문자가 있는 위치를 찾아내는 방법은 find() 멤버 함수를 활용합니다.
이 함수는 문자열에서 주어진 문자 또는 문자열을 찾아, 해당 위치를 반환합니다.
find() 함수의 두 번째 인자는 검색을 시작할 위치를 지정하는 인자입니다.
따라서 start 변수에 이전에 찾은 , 문자의 위치를 저장하고, 이를 시작 위치로 지정하여 , 문자를 찾아냅니다.
이렇게 찾은 문자열은 substr() 멤버 함수를 활용하여 추출합니다.
이 함수는 문자열에서 주어진 위치부터 지정한 길이만큼의 문자열을 반환합니다.
2) 저장된 문자열을 역순으로 출력하는 방법
이 예제에서는 std::vector 컨테이너의 멤버 함수인 rbegin()과 rend()를 활용하여 반복자(iterator)를 역순으로 순회합니다.
이렇게 역순으로 순회하면서 저장된 문자열을 출력합니다.
이러한 방식으로 std::string 클래스의 멤버 함수와 std::vector 컨테이너를 활용하여 문자열을 분리하고, 저장된 문자열을 처리하는 다양한 기능을 구현할 수 있습니다.

std::string 클래스의 내부 구현에서는 또한 문자열 데이터의 내부 인코딩에 대한 처리도 이루어집니다.

std::string 클래스는 기본적으로 ASCII나 UTF-8 인코딩을 사용하지만, 다른 인코딩을 사용하는 경우에도 멤버 함수를 통해 문자열 데이터를 적절하게 변환할 수 있습니다.

즉, std::string 클래스는 문자열 데이터를 동적으로 할당하고, 문자열을 조작하는 다양한 멤버 함수들을 제공하는 라이브러리 클래스입니다. 내부적으로는 문자열 데이터를 저장하기 위한 메모리 관리와 문자열 조작 함수들의 구현 등이 이루어지며, 이를 통해 문자열 데이터를 효율적으로 처리할 수 있습니다.

알게되다 / 알아차리다 / 알아내다 /잘 알다 /판단하다 영어로

꼬북칩조아 — Wed, 29 Mar 2023 06:44:46 +0900

1. know: 사실, 정보를 알고 있는 상태.

네 이메일 주소 알아

☞ I know your email address.

네가 어제 뭐했는지 알아

☞ I know what you did yesterday.

2. Understand: 이해하다 이지만 알다로 해석되는 경우 많음.

어떤 마음이신지 알아요

☞ I understand how you feel

그녀가 왜 그랬는지 알아요. 그런데 그 결정에 동의하진 않아요

☞ I understand why she did that. But i don't agree with her decision

무슨 의민지 이해가 안가요

☞ I don't understand what it means

무슨말인지 이해해요

☞ I understand what you told.

그들이 그 상황에서 왜그랬는지 이해가 안돼요

☞ I don't understand why they did in that situation.

3. find out: 몰랐던 사실, '정보'를 알게 되다. 그 과정, 변화를 이야기함.

난 그걸 어제서야 알았어요

☞ I found out that (just) yesterday

다음 뉴욕행 기차 출발 시간을 알아내야 해

☞ I need to find out the time of the next train to New york

경찰은 누가 범인인지 찾고 있어

☞ The police are trying to find out who committed the crime

일요일에 그 식당이 영업하는지 알아보자

☞ Let's find out if the restaurant is open on sundays

우리는 프로젝트가 일정에 뒤처지는 이유를 알아내야 돼

☞ We need to find out why the project is begind the schedule

4. figure out: 몰랐던 '문제'의 해결책, 방법을 알게 되다. 그 과정,변화를 이야기함."알아냈어"
+ "이해하기 위해 노력하는 것"

이 가구 조립하는 방법을 이해할 수 없어

☞ I can't figure out how to assemble this furniture

우리는 지출을 줄이는 방법을 찾아야 돼

☞ We need to figure out a way to reduce our expenses

우리는 여전히 그 문제에 대한 해결책을 찾고있다

☞ We are still trying to figure out a solution to the problem

파티에서 뭐 입을지 결정해야돼

☞ I need to figure out what to wear to the party

어떻게 사용하는 건지 알았어

☞ I figured out how to use it

이 문제를 어떻게 해결할 수 있는지 알 수 있나요?

☞ Can you figure out how to fix this problem?

새로운 프로젝트에 대해 무엇을 파악했나요?

☞ What did you figure out about the new project?

그는 새로운 소프트웨어를 어떻게 사용해야 하는지 아직 알아내지 못했나요?

☞ Has he figured out how to use the new software yet?

이 맛있는 요리를 어디에서 배웠나요?

☞ Where did you figure out how to cook this delicious meal?

5. realize: 몰랐던 문제가 뭔지 깨달아 알다. 그 과정은 머릿속에서 이뤄지는 뉘앙스.

문제가 뭔지 (마침내) 알았어

☞ I (finally) realized what the problem was.

I finally find out what the problem was (X)

내가 큰 실수 했다는 걸 알았어

☞ I realized that I made a big mistake.

우리는 우리 여권을 집에 두고 온 걸 깨달았다.

☞ We realized that we had left our passports at home.

그가 계속 거짓말을 해왔다는 걸 깨달았나요?

☞ Have you realized that he's been lying to you this whole time?

그는 시험에 실패한 후에 그는 열심히 공부하는 것의 중요성을 깨달았다.

☞ He realized the importance of studying hard after failing his exams.

이 아름다운 경치가 얼마나 아름다운지 깨달았나요?

☞ Did you ever realize how beautiful this view is?

*realize 는 머릿속에서만 벌어지는 일; 깨닳음, notice 는 외부와의 접촉 (보고 , 듣고 하는 등)

6. notice: 알리다라는 뜻이 아니고, 뭔가를 보고 특이한 점, 바뀐점을 캐치해 알다. 알아차리다.

오늘 학교에서 내친구 봤는데, 머리 잘랐더라구 (머리자른걸 알아챘어)

☞ I saw my friend at school today and I noticed (that) she had gotten a haircut

그녀가 새 앨범을 냈는데, 스타일이 좀 바뀌었더라구

☞ She came out(released) with a new album and I noticed (that) her style had changed a little bit

오늘 아침에 길에서 친구랑 마주쳤는데 모습이 약간 바꼈더라구

☞ I ran into my friend on the street this morning, and I noticed she looked a little different

그녀가 신상 신발 신고있었던걸 알아챘었어

☞ I noticed that she had worn brand new shoes.

오늘 커피 많이 마시던데, 어제 잠 잘 못잤니?

☞ I noticed you were drinking a lot of coffee today, did you have trouble sleeping last night?

*notify : 알리다; notification : 알림

7. recognize: 알아차리다란 뜻이 아니고, 뭔가를 보고 그게 뭔지, 누구인지 아는것을 의미. "뭔지/누군지 알다"

오늘아침에 길에서 누군가가 나한테 인사 했는데, 누군지 몰라봤어

☞ This morning, someone said hello to me on the street, but I didn't recognize him

그녀가 되게 친숙한데 누군지는 모르겠어

☞ She looked very familiar, but I couldn't recognize her

어제밤에 클럽에서 전 남친을 만났는데, 못알아본체 했어

☞ I ran into my ex-boy friend at the club last night. but I pretended not to recognize him.

당신 남편의 손글씨를 보면, 알아보시겠어요?

☞ If you saw your husband's handwriting, would you recognize it?

8. be aware of~: 어떤것의 존재 여부에 대해 알다.

그런 정책이 있는지 몰랐어요

☞ I wasn't aware of that policy

그들은 그런 룰이 있는지 알고있었어요

☞ They were aware of the rules

그 당시에 그런 상황에 대해서 인지하지 못하고 있었어요 (모르고 있었어요)

☞ They were not aware of the situation at the time

9. be familiar with~: ~어떤 사물등에 대해 잘 알다. 잘 숙지하고 있다. "잘 알다"

저는 이 주제에 대해 잘 몰라요

☞ I'm not very familiar with this topic

이런 상황을 잘 아세요?

☞ Are you familiar with this kind of situation?

전 이 분야에 대해 잘 몰라요. 한국 역사에 대해 잘 아세요?

☞ I am not familiar with this area. Are you familiar with Korean history?

*know well 은 가급적으로 안쓰는 것이 좋고 쓴다면 사람한테만.

10. tell: 말하다는 뜻 외에 판단해서 알다는 의미가 있음. 지식이 아닌 판단에 대한 것."판단하다"

뭐라고 쓰여있는지 모르겠어

☞ I can't tell what it says

*이런 상황에서 I don't know what it says (X) 내 지식에 대해 말하는 것은 어색하므로

무슨 차인지 모르겠어.어떻게 다른지 말해줄래?

☞ I can't tell the difference. can you tell me how they are different.

이게 뭔지 알겠어? 이게 물인거 같아?

☞ Can you tell what this is ? Do you think it's water ?

*Do you know what this is ? 라고 하면 안됨 (지금 이순간에 이거 보고 판단이 되는지 묻는 상황이므로)

일란성 쌍둥이를 구분하는게 나한텐 쉽지 않네요

☞ It's not easy for me to tell identical twins.

"알다"를 어떻게 정확하게 사용하는지 마침내 알았어요

제가 잘못된 방법으로 영어를 공부했었다는 것도 깨달았네요

영어로 "알다"라는 표현을 하는 방법이 많은 줄 몰랐네요

놀라운 강의 감사해요

당신은 영어랑 한국어 둘다 잘 아시는 것 같아요

I finally found out how to use "알다"orrectly.

I have realized that I studied English in the wrong way.

I wasn't aware there are many ways to express "알다" in English.

Thanks to your amazing lecture.

You look really familiar with English and Korean.

출처: 유튜브 채널 '라이브 아카데미' 및 해당 영상 댓글 참고

[디자인 패턴] chain of responsibility

꼬북칩조아 — Tue, 28 Mar 2023 21:02:57 +0900

Chain of Responsibility Pattern

객체 지향 디자인 패턴 중 하나로, 요청을 처리하는 객체들을 연결하여 처리의 책임을 분산시키는 패턴입니다.

이 패턴은 일종의 체인으로 구성되어 있으며, 하나의 요청을 받은 객체가 해당 요청을 처리하지 못할 경우,

이를 다음 객체로 전달하여 계속해서 요청 처리를 시도합니다.

이러한 과정에서 요청을 처리할 객체를 찾을 때까지 요청이 계속해서 전달되며, 이를 통해 요청 처리의 책임이 분산됩니다.

이 패턴은 보안 검사, 로깅 등의 작업에서 유용하게 사용될 수 있습니다.

예를 들어, 여러 개의 보안 검사를 수행하는 시스템에서, 각 검사를 담당하는 객체들을 체인으로 연결하여 요청이 전달되는 과정에서 필요한 보안 검사를 수행할 수 있습니다. 또한, 이 패턴은 객체 간 결합도를 낮추고, 유연성과 확장성을 높이는 데에도 도움이 됩니다.

이 패턴을 구현하기 위해서는, 요청 처리 객체들이 각각의 인터페이스를 구현하고, 요청 처리에 대한 메소드를 구현해야 합니다.

또한, 객체 간의 연결 관계를 설정할 수 있는 방법이 필요하며, 일반적으로는 체인 형태의 구조를 가진 리스트나 연결 리스트를 사용합니다.

여러 객체들이 연결되어 있는 형태이기 때문에, 요청 처리 과정에서 루프를 돌지 않도록 주의해야 합니다. 특히, 요청 처리 객체가 너무 많아지면, 체인의 끝까지 요청이 전달되지 못하거나, 처리 속도가 느려지는 등의 문제가 발생할 수 있으므로, 적절한 객체 수를 유지해야 합니다.

예제1)

#include <iostream>
#include <string>

class Validator {
public:
    virtual void setNext(Validator* next) = 0;
    virtual void validate(std::string data) = 0;
};

class LengthValidator : public Validator {
public:
    void setNext(Validator* next) override {
        this->next = next;
    }

    void validate(std::string data) override {
        if (data.length() > 10) {
            std::cout << "Data too long!" << std::endl;
            return;
        }

        if (next != nullptr) {
            next->validate(data);
        }
    }

private:
    Validator* next = nullptr;
};

class SymbolValidator : public Validator {
public:
    void setNext(Validator* next) override {
        this->next = next;
    }

    void validate(std::string data) override {
        if (data.find_first_of("!@#$%^&*()") != std::string::npos) {
            std::cout << "Data contains forbidden symbols!" << std::endl;
            return;
        }

        if (next != nullptr) {
            next->validate(data);
        }
    }

private:
    Validator* next = nullptr;
};

class NumberValidator : public Validator {
public:
    void setNext(Validator* next) override {
        this->next = next;
    }

    void validate(std::string data) override {
        if (data.find_first_of("0123456789") != std::string::npos) {
            std::cout << "Data contains numbers!" << std::endl;
            return;
        }

        if (next != nullptr) {
            next->validate(data);
        }
    }

private:
    Validator* next = nullptr;
};

int main() {
    Validator* validator = new LengthValidator();
    validator->setNext(new SymbolValidator());
    validator->setNext(new NumberValidator());

    validator->validate("test123");
    validator->validate("test123!!!"); // Should fail length and symbol validation
    validator->validate("testtesttest"); // Should fail length validation
    validator->validate("testtesttest123"); // Should pass all validations

    return 0;
}

이 예제 코드는 문자열의 길이, 특수문자, 숫자 등을 검사하는 간단한 예제입니다.

각 검사를 담당하는 클래스를 구현하고, 각 클래스들을 연결하여 체인을 만들고, 체인 상에서 검사를 수행합니다

인터페이스 : setNext(Validator* next), validate(std::string data)

객체 간의 연결 관계 : 연결 리스트

예제2) 파일 업로드 시 보안 검사를 수행하는 시스템

#include <iostream>
#include <string>
#include <vector>

class SecurityCheck {
public:
    virtual void check(const std::string& file) = 0;
};

class FileExtensionCheck : public SecurityCheck {
public:
    void check(const std::string& file) override {
        if (file.find(".exe") != std::string::npos ||
            file.find(".dll") != std::string::npos ||
            file.find(".bat") != std::string::npos) {
            std::cout << "File extension not allowed!" << std::endl;
            return;
        }

        std::cout << "File extension check passed." << std::endl;
    }
};

class FileSizeCheck : public SecurityCheck {
public:
    void check(const std::string& file) override {
        if (file.length() > 1024 * 1024) {
            std::cout << "File size too big!" << std::endl;
            return;
        }

        std::cout << "File size check passed." << std::endl;
    }
};

class VirusScanCheck : public SecurityCheck {
public:
    void check(const std::string& file) override {
        std::cout << "Scanning for viruses..." << std::endl;
        // perform virus scan here

        std::cout << "Virus scan check passed." << std::endl;
    }
};

class SecurityCheckSystem {
public:
    void addCheck(SecurityCheck* check) {
        checks.push_back(check);
    }

    void runChecks(const std::string& file) {
        for (SecurityCheck* check : checks) {
            check->check(file);
        }
    }

private:
    std::vector<SecurityCheck*> checks;
};

int main() {
    SecurityCheckSystem system;
    system.addCheck(new FileExtensionCheck());
    system.addCheck(new FileSizeCheck());
    system.addCheck(new VirusScanCheck());

    std::string filename = "example.txt";
    system.runChecks(filename);

    return 0;
}

이 예제 코드는 파일 확장자, 파일 크기, 바이러스 검사를 수행하는 간단한 보안 검사 시스템입니다.

각 검사를 수행하는 클래스를 구현하고, 이를 SecurityCheck 인터페이스로 추상화합니다.

그리고 SecurityCheckSystem 클래스에서는 이러한 검사들을 추가하고, 파일에 대해 이러한 검사들을 수행합니다.

이때, SecurityCheckSystem 클래스는 SecurityCheck 인터페이스를 사용하여 다형성을 지원합니다.

예제3) 로깅 시스템

#include <iostream>
#include <string>
#include <vector>

// Abstract base class for loggers
class Logger {
public:
	virtual ~Logger() {}
    virtual void log(const std::string& message, int level) = 0;
};

// Console logger
class ConsoleLogger : public Logger {
public:
    void log(const std::string& message, int level) override {
        std::cout << "Console logger: " << message << " (level " << level << ")" << std::endl;
    }
};

// File logger
class FileLogger : public Logger {
public:
    FileLogger(const std::string& filename) : filename(filename) {}

    void log(const std::string& message, int level) override {
        std::cout << "File logger: " << message << " (level " << level << ") -> " << filename << std::endl;
        // write message to file here
    }

private:
    std::string filename;
};

// Email logger
class EmailLogger : public Logger {
public:
    EmailLogger(const std::string& email) : email(email) {}

    void log(const std::string& message, int level) override {
        std::cout << "Email logger: " << message << " (level " << level << ") -> " << email << std::endl;
        // send email here
    }

private:
    std::string email;
};

// Chain of responsibility class
class LoggerChain {
public:
    LoggerChain(Logger* logger) : logger(logger) {}

    void addLogger(Logger* newLogger) {
        if (nextLogger) {
            nextLogger->addLogger(newLogger);
        } else {
            nextLogger = new LoggerChain(newLogger);
        }
    }

    void log(const std::string& message, int level) {
        if (level <= logLevel) {
            logger->log(message, level);
        }
        if (nextLogger) {
            nextLogger->log(message, level);
        }
    }

    void setLogLevel(int level) {
        logLevel = level;
    }

private:
    Logger* logger;
    LoggerChain* nextLogger = nullptr;
    int logLevel = 0;
};

int main() {
    // Create loggers
    Logger* consoleLogger = new ConsoleLogger();
    Logger* fileLogger = new FileLogger("log.txt");
    Logger* emailLogger = new EmailLogger("admin@example.com");

    // Create chain of responsibility
    LoggerChain chain(consoleLogger);
    chain.addLogger(fileLogger);
    chain.addLogger(emailLogger);

    // Set log level
    chain.setLogLevel(2);

    // Log messages
    chain.log("This is a debug message", 1);
    chain.log("This is an informational message", 2);
    chain.log("This is a warning message", 3);

    return 0;
}

이 예제 코드는 로그를 출력하는 Logger 추상 클래스와 이를 구현하는 ConsoleLogger, FileLogger, EmailLogger 클래스를 정의합니다. 그리고 LoggerChain 클래스에서는 이러한 로그를 처리하는 체인을 구성합니다.

LoggerChain 클래스는 Logger 객체를 멤버로 가지며, 체인의 다음 로거를 가리키는 포인터를 가집니다.

addLogger 함수에서는 새로운 로거를 추가하고, log 함수에서는 현재 로거에서 로그를 출력하고, setLogLevel 함수는 로그 레벨을 설정하며, main 함수에서는 각 로거를 생성하고 LoggerChain 클래스를 사용하여 로그 메시지를 출력합니다.

Console logger: This is an informational message (level 2)
File logger: This is an informational message (level 2) -> log.txt
Email logger: This is an informational message (level 2) -> admin@example.com
File logger: This is a warning message (level 3) -> log.txt
Email logger: This is a warning message (level 3) -> admin@example.com

이 예제에서는 로그 레벨이 2로 설정되어 있으므로, 레벨이 2 이하인 로그 메시지만 출력됩니다.

또한, LoggerChain 클래스를 사용하여 로그를 처리하는 체인을 구성하여, 여러 로거를 연결하여 로그 메시지를 출력할 수 있습니다.

+ Improvement

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

// Abstract base class for loggers
class Logger {
public:
    virtual ~Logger() {}
    virtual void log(const std::string& message, int level) = 0;
};

// Console logger
class ConsoleLogger : public Logger {
public:
    void log(const std::string& message, int level) override {
        if (level <= m_level) {
            std::cout << "Console logger: " << message << std::endl;
        }
    }
    void setLevel(int level) { m_level = level; }
private:
    int m_level = 1;
};

// File logger
class FileLogger : public Logger {
public:
    FileLogger(const std::string& filename) : m_filename(filename) {}
    void log(const std::string& message, int level) override {
        if (level <= m_level) {
            std::ofstream file(m_filename, std::ios_base::app);
            file << "File logger: " << message << " -> " << m_filename << std::endl;
        }
    }
    void setLevel(int level) { m_level = level; }
private:
    std::string m_filename;
    int m_level = 2;
};

// Email logger
class EmailLogger : public Logger {
public:
    EmailLogger(const std::string& email) : m_email(email) {}
    void log(const std::string& message, int level) override {
        if (level <= m_level) {
            std::cout << "Email logger: " << message << " -> " << m_email << std::endl;
        }
    }
    void setLevel(int level) { m_level = level; }
private:
    std::string m_email;
    int m_level = 3;
};

// Logger chain
class LoggerChain {
public:
    void addLogger(Logger* logger) {
        m_loggers.push_back(logger);
    }
    void log(const std::string& message, int level) {
        for (auto logger : m_loggers) {
            logger->log(message, level);
        }
    }
private:
    std::vector<Logger*> m_loggers;
};

// Logging system
class LoggingSystem {
public:
    LoggingSystem() {
        m_loggerChain.addLogger(&m_consoleLogger);
        m_loggerChain.addLogger(&m_fileLogger);
        m_loggerChain.addLogger(&m_emailLogger);
    }
    void setLogLevel(int level) {
        m_consoleLogger.setLevel(level);
        m_fileLogger.setLevel(level);
        m_emailLogger.setLevel(level);
    }
    void log(const std::string& message, int level) {
        m_loggerChain.log(message, level);
    }
private:
    ConsoleLogger m_consoleLogger;
    FileLogger m_fileLogger{"log.txt"};
    EmailLogger m_emailLogger{"admin@example.com"};
    LoggerChain m_loggerChain;
};

// Main function
int main() {
    LoggingSystem loggingSystem;
    loggingSystem.setLogLevel(2);
    loggingSystem.log("This is an informational message", 2);
    loggingSystem.log("This is a warning message", 3);
    return 0;
}

[C++] shared_ptr 사용시 주의할 점

꼬북칩조아 — Mon, 27 Mar 2023 17:56:55 +0900

1. 순환 참조 문제

(예제1)

#include <memory>
#include <iostream>

struct Node {
    std::shared_ptr<Node> next;
    int value;
    Node(int val): value(val) {
        std::cout << "Node " << value << " created." << std::endl;
    }
    ~Node() {
        std::cout << "Node " << value << " destroyed." << std::endl;
    }
};

int main() {
    std::shared_ptr<Node> head = std::make_shared<Node>(1);
    std::shared_ptr<Node> second = std::make_shared<Node>(2);
    std::shared_ptr<Node> third = std::make_shared<Node>(3);
    
    head->next = second;
    second->next = third;
    third->next = head; // 순환 참조
    
    return 0;
}

위 예제에서 Node 구조체는 단순히 value와 다음 노드를 가리키는 next 멤버 변수를 가지고 있습니다.

main 함수에서는 head, second, third 세 개의 노드를 생성하고 next 포인터로 연결합니다.

그런데 third 노드에서 head 노드를 가리키는 것을 볼 수 있습니다.

이로 인해 head가 참조하는 객체의 reference count가 2가 되어 메모리에서 해제되지 않고 유지됩니다.

프로그램을 실행해보면 다음과 같은 출력을 확인할 수 있습니다.

Node 1 created.
Node 2 created.
Node 3 created.
Node 1 destroyed.

(예제2)

#include <memory>
#include <iostream>

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;
    int value;
    Node(int val): value(val) {
        std::cout << "Node " << value << " created." << std::endl;
    }
    ~Node() {
        std::cout << "Node " << value << " destroyed." << std::endl;
    }
};

int main() {
    std::shared_ptr<Node> head = std::make_shared<Node>(1);
    std::shared_ptr<Node> second = std::make_shared<Node>(2);
    std::shared_ptr<Node> third = std::make_shared<Node>(3);
    
    head->next = second;
    second->prev = head;
    second->next = third;
    third->prev = second;
    third->next = head; // 순환 참조
    
    return 0;
}

이 예제에서는 Node 구조체에 prev라는 멤버 변수를 추가했습니다.

prev는 현재 노드의 이전 노드를 가리키는 weak_ptr입니다.

main 함수에서는 head, second, third 세 개의 노드를 생성하고 next와 prev 포인터로 연결합니다.

이번에도 third 노드에서 head 노드를 가리키는 것을 볼 수 있습니다.

프로그램을 실행해보면 다음과 같은 출력을 확인할 수 있습니다.

Node 1 created.
Node 2 created.
Node 3 created.
Node 1 destroyed.
Node 2 destroyed.
Node 3 destroyed.

세 개의 노드가 모두 생성된 후 main 함수가 끝나면서 head, second, third가 소멸됩니다.

그리고 head가 참조하는 노드는 third에서도 참조되고 있으므로 reference count가 2인 상태로 남아있게 됩니다.

또한 second는 head를 가리키는 prev 포인터를 가지고 있지만 weak_ptr을 사용했기 때문에 head가 소멸됨에 따라 prev 포인터는 무효화됩니다.

이로 인해 Node 1 destroyed., Node 2 destroyed. 메시지가 출력되지 않습니다.

이와 같이 shared_ptr이 더 복잡한 순환 참조 문제를 일으킬 수 있으므로, 이러한 문제가 발생하지 않도록 설계를 잘 해야 합니다.

순환 참조를 방지하기 위해서는 weak_ptr을 사용하거나, shared_ptr 대신 unique_ptr을 사용하거나, 참조를 다른 객체에게 위임하는 방식을 사용하는 등의 방법이 있습니다.

2. shared_ptr 에 raw pointer 를 대입할 때 발생하는 문제

#include <memory>
#include <iostream>

struct Node {
    std::shared_ptr<Node> next;
    int value;
    Node(int val): value(val) {
        std::cout << "Node " << value << " created." << std::endl;
    }
    ~Node() {
        std::cout << "Node " << value << " destroyed." << std::endl;
    }
};

int main() {
    std::shared_ptr<Node> head = std::make_shared<Node>(1);
    std::shared_ptr<Node> second = std::make_shared<Node>(2);
    
    head->next = second;
    second->next = head;

    std::shared_ptr<Node> third(head->next.get()); // raw pointer를 대입
    
    return 0;
}

이 예제에서는 third라는 새로운 shared_ptr을 생성할 때, head의 next 포인터를 가리키는 raw pointer를 사용합니다.

이렇게 되면 third와 head는 같은 객체를 참조하게 됩니다. 따라서 head와 second도 같은 객체를 참조하게 됩니다.

프로그램을 실행해보면 다음과 같은 출력을 확인할 수 있습니다.

Node 1 created.
Node 2 created.

두 개의 노드가 생성된 후 main 함수가 끝나면서 head, second, third가 소멸됩니다.

그러나 head와 second는 같은 객체를 참조하고 있으므로 reference count가 2인 상태로 남아있게 됩니다.

이로 인해 Node 1 destroyed., Node 2 destroyed. 메시지가 출력되지 않습니다.

이와 같이 raw pointer를 사용하여 shared_ptr이 같은 객체를 참조하게 되면, 객체가 제대로 해제되지 않는 문제가 발생할 수 있습니다. 이러한 문제를 방지하기 위해서는 raw pointer를 사용하는 것을 지양하고,

가능하면 shared_ptr 또는 weak_ptr을 사용하여 참조 관리를 해주는 것이 좋습니다.

3. std::enable_shared_from_this 를 상속받아야 shared_ptr 의 안전한 사용이 가능한 이유

C++11에서 std::enable_shared_from_this를 상속받는 클래스는 해당 객체가 std::shared_ptr에 의해 관리되는 경우, std::shared_ptr가 객체를 안전하게 참조할 수 있도록 해줍니다.

이를 통해 shared_ptr이 안전하게 사용될 수 있는 이유는 다음과 같습니다.

std::shared_ptr은 객체의 reference count를 관리하며, 객체가 참조하는 모든 std::shared_ptr이 소멸될 때 해당 객체도 소멸됩니다. 그러나 이 때 참조하는 모든 std::shared_ptr이 소멸되어 reference count가 0이 되어야만 객체가 소멸되기 때문에, shared_ptr에 대한 순환 참조 문제가 발생할 수 있습니다.

즉, 객체가 참조하는 shared_ptr과 객체 자체를 참조하는 shared_ptr이 서로를 참조하는 순환 참조 문제가 발생할 수 있습니다.

std::enable_shared_from_this는 이러한 순환 참조 문제를 해결하기 위해, 해당 클래스에서 shared_from_this() 함수를 제공합니다. 이 함수는 std::shared_ptr의 인스턴스를 생성하면서 해당 객체를 가리키는 포인터를 반환합니다.

이 함수는 해당 객체가 std::shared_ptr에 의해 참조될 때 호출되어 std::shared_ptr의 내부 참조 카운트를 증가시킵니다.

또한 이 함수는 해당 객체가 이미 std::shared_ptr에 의해 관리되고 있지 않은 경우, std::bad_weak_ptr 예외를 발생시킵니다.

따라서, std::enable_shared_from_this를 상속받는 클래스에서 shared_from_this() 함수를 사용하여 객체를 안전하게 참조하면,

순환 참조 문제를 방지하면서 std::shared_ptr에 의해 안전하게 관리될 수 있습니다.

< std::enable_shared_from_this >

std::enable_shared_from_this 클래스는 std::shared_ptr에서 객체의 안전한 참조 계수(reference counting)를 관리하기 위한 기능을 제공합니다. 이 클래스는 std::shared_ptr를 사용하여 동적으로 할당된 객체의 참조 계수를 추적하는 데 필요한 일부 메커니즘을 구현합니다.

보통 std::shared_ptr를 사용하여 객체를 참조하는 경우, 해당 객체를 참조하는 모든 std::shared_ptr의 참조 계수가 1씩 증가하고, std::shared_ptr가 객체의 스코프를 벗어나면 참조 계수가 1씩 감소합니다. 이러한 메커니즘은 객체의 안전한 수명 관리를 보장합니다.

그러나 클래스 내부에서 std::shared_ptr의 사용을 제어하기 위해서는 std::enable_shared_from_this 클래스를 상속받아야 합니다. 이를 상속받은 클래스에서는 shared_from_this() 멤버 함수를 사용하여 this 포인터로부터 std::shared_ptr 인스턴스를 생성할 수 있습니다. 이렇게 생성된 std::shared_ptr은 해당 객체를 참조하는 다른 std::shared_ptr 인스턴스와 함께 안전하게 참조 계수를 관리할 수 있습니다.

따라서 std::enable_shared_from_this 클래스는 객체가 안전하게 참조되는 것을 보장하기 위한 용도로 사용됩니다.

#include <memory>
#include <iostream>

class MyClass : public std::enable_shared_from_this<MyClass>
{
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }

    std::shared_ptr<MyClass> getSharedPtr() { return shared_from_this(); }
};

int main()
{
    std::shared_ptr<MyClass> p1(new MyClass());
    std::shared_ptr<MyClass> p2 = p1->getSharedPtr();

    std::cout << "p1 use_count: " << p1.use_count() << std::endl; // 2
    std::cout << "p2 use_count: " << p2.use_count() << std::endl; // 2

    p1.reset();
    std::cout << "p2 use_count after reset p1: " << p2.use_count() << std::endl; // 1

    p2.reset();
    std::cout << "End of program" << std::endl;

    return 0;
}

위 코드에서 MyClass는 std::enable_shared_from_this<MyClass>를 상속받습니다.

그리고 getSharedPtr() 함수는 shared_from_this() 함수를 호출하여 현재 객체를 가리키는 std::shared_ptr을 반환합니다.

main() 함수에서는 p1과 p2라는 두 개의 std::shared_ptr 인스턴스를 생성합니다.

p1은 new MyClass()로 생성된 객체를 가리키고, p2는 p1의 getSharedPtr() 함수를 호출하여 생성된 std::shared_ptr을 가리킵니다.

그리고 p1의 reference count를 출력하면 2가 출력되는 것을 볼 수 있습니다.

이는 p1과 p2가 동일한 객체를 가리키기 때문입니다.

이후 p1을 reset() 메소드를 통해 소멸시키면, p2의 reference count가 1이 되는 것을 확인할 수 있습니다.

마지막으로 p2를 reset() 메소드를 통해 소멸시키면, MyClass 객체도 함께 소멸됩니다.

이때 MyClass 객체의 소멸자가 호출되며, "MyClass destructor" 메시지가 출력됩니다.

std::enable_shared_from_this를 상속받지 않은 클래스에서 shared_from_this() 함수를 사용하는 예제

#include <memory>
#include <iostream>

class MyClass
{
public:
    MyClass() { std::cout << "MyClass constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass destructor" << std::endl; }

    std::shared_ptr<MyClass> getSharedPtr() { return shared_from_this(); }
};

int main()
{
    std::shared_ptr<MyClass> p1(new MyClass());
    std::shared_ptr<MyClass> p2 = p1->getSharedPtr();

    std::cout << "p1 use_count: " << p1.use_count() << std::endl; // 1
    std::cout << "p2 use_count: " << p2.use_count() << std::endl; // 1

    p1.reset();
    std::cout << "p2 use_count after reset p1: " << p2.use_count() << std::endl; // 1

    p2.reset();
    std::cout << "End of program" << std::endl;

    return 0;
}

위 코드에서 MyClass는 std::enable_shared_from_this<MyClass>를 상속받지 않습니다. 그리고 getSharedPtr() 함수는 shared_from_this() 함수를 호출하여 현재 객체를 가리키는 std::shared_ptr을 반환합니다.

main() 함수에서는 p1과 p2라는 두 개의 std::shared_ptr 인스턴스를 생성합니다. p1은 new MyClass()로 생성된 객체를 가리키고,

p2는 p1의 getSharedPtr() 함수를 호출하여 생성된 std::shared_ptr을 가리킵니다.

그러나 MyClass 클래스는 std::enable_shared_from_this<MyClass>를 상속받지 않았기 때문에 shared_from_this() 함수가 사용될 때 문제가 발생합니다. 이 예제에서 shared_from_this() 함수를 호출하면, std::bad_weak_ptr 예외가 발생합니다.

따라서 main() 함수에서 p1과 p2의 reference count는 모두 1인 상태이며, 둘 다 reset() 메소드를 호출하면 객체가 제대로 소멸됩니다.

4. 사용자 지정 deleter 를 사용

std::shared_ptr에서 사용자 정의 deleter를 지정하여 메모리 할당과 해제를 처리하는 예제입니다.

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int n = 0) : num(n) {}
    void print() { std::cout << "MyClass::num = " << num << std::endl; }
private:
    int num;
};

void custom_deleter(MyClass* p) {
    std::cout << "Custom deleter called" << std::endl;
    delete p;
}

int main() {
    std::shared_ptr<MyClass> sp1(new MyClass(1), custom_deleter);
    std::shared_ptr<MyClass> sp2(new MyClass(2), [](MyClass* p) { std::cout << "Lambda deleter called" << std::endl; delete p; });
    
    sp1->print();
    sp2->print();
    
    return 0;
}

위 예제에서는 std::shared_ptr를 사용하여 MyClass 객체를 생성합니다.

std::shared_ptr의 생성자에서 두 번째 인자로 사용자 정의 deleter를 지정하고 있습니다.

첫 번째 std::shared_ptr는 함수 custom_deleter를, 두 번째 std::shared_ptr는 람다 함수를 사용하여 deleter를 지정하고 있습니다.

custom_deleter 함수는 객체를 삭제하기 전에 "Custom deleter called"라는 메시지를 출력합니다.

람다 함수는 객체를 삭제하기 전에 "Lambda deleter called"라는 메시지를 출력합니다.

따라서, std::shared_ptr를 통해 객체를 참조하다가 std::shared_ptr의 수명이 끝나면 사용자 정의 deleter가 호출되어 객체를 삭제합니다.

[C++] 상수 객체 (const object) 와 상수 멤버함수 (const member function) 및 const 반환(return), 포인터(pointer)

꼬북칩조아 — Mon, 27 Mar 2023 08:00:38 +0900

상수 객체 (const object)

C++에서 상수(const) 객체는 그 값이 변경될 수 없는 객체입니다.

상수 객체는 객체를 생성할 때 값이 할당되며, 이후에는 변경되지 않습니다.

const int num = 10; // 'num'은 상수 객체이며, 값은 10입니다.

위 드에서 const 키워드는 num 변수가 상수임을 나타냅니다. 이후에는 num의 값을 변경할 수 없습니다.

상수 객체는 객체 지향 프로그래밍에서 매우 중요한 역할을 합니다.

상수 객체를 사용하면, 값이 변경되면 안되는 상황에서 값이 변경되는 것을 방지할 수 있습니다.

또한, 상수 객체를 이용하면 컴파일러가 값을 임베딩(embedding)할 수 있어서, 코드의 실행 속도를 높일 수 있습니다.

코드의 실행 속도를 높일 수 있는 이유

상수 객체는 일반적으로 값을 변경할 수 없기 때문에, 컴파일러는 이러한 객체를 메모리에 상수로 저장하도록 최적화할 수 있습니다.

이를 통해 실행 속도를 향상시키고, 프로그램의 안정성을 높일 수 있습니다

1. 메모리 접근 시간 단축

상수 객체의 값을 직접 코드에 삽입함으로써, 상수 객체의 값을 참조하기 위한 메모리 접근을 생략할 수 있습니다.

이는 프로그램 실행 시간을 단축시키는데 큰 도움이 됩니다.

const int num = 10;
int x = num + 5;

컴파일러는 num + 5를 15로 대체할 수 있습니다.

이렇게 상수 값을 바로 사용하면, 변수나 메모리를 참조하지 않고 값을 얻을 수 있으므로 실행 속도를 높일 수 있습니다.

2. 코드 크기 감소

상수 객체를 사용하면, 상수 값이 중복해서 사용될 때 메모리에 상수 값의 복사본이 저장되는 것을 방지할 수 있습니다.

대신, 컴파일러는 상수 값을 임베딩해서 사용하므로 코드 크기가 감소하게 됩니다.

상수 값을 메모리에 저장할 경우, 상수 값이 여러 번 사용될 때마다 해당 메모리 주소를 참조하므로 코드가 길어질 수 있습니다.

하지만 상수 값을 임베딩하면 코드가 더 간결해지고, 프로그램의 크기가 작아질 수 있습니다.

결론적으로, 상수 객체를 이용하면 컴파일러가 값을 임베딩할 수 있어서, 코드의 실행 속도를 높일 수 있습니다.

이를 통해 프로그램의 성능을 향상시킬 수 있습니다.

C++에서 상수 객체는 전역 상수(constant)와 지역 상수(constant)로 나뉘어서 메모리의 서로 다른 영역에 저장됩니다.

전역 상수는 프로그램이 실행될 때 프로그램의 데이터 섹션(data section)에 저장됩니다.

데이터 섹션은 전역 변수와 정적(static) 변수도 저장하는 영역으로, 프로그램이 종료될 때까지 메모리에 남아있습니다.

지역 상수는 해당 변수가 정의된 블록이 실행될 때 스택(stack) 메모리 영역에 저장됩니다.

블록이 실행될 때마다 해당 상수의 값을 읽어와서 사용하며, 블록이 끝나면 해당 상수는 스택에서 제거됩니다.

상수 멤버함수 (const member function)

상수 멤버함수란 클래스 멤버함수 선언 뒤에 'const' 키워드로 선언 된 함수로,

상수 멤버 함수 안에서는 모든 멤버를 상수 처리한다는 특징이 있습니다.

여기서 상수 처리한다는 것은 함수 내부에서 사용되는 변수 값을 바꿀 수 없다는 의미입니다.

#include <iostream>

class Point
{
private:
	int x, y;

public:	
	Point(int a = 0, int b= 0) : x(a), y(b) {}

	void set(int a, int b)
	{
		x= a;
		y= b;
	}
	void print() const // 상수 멤버 함수 : 안에서 모든 멤버를 상수처리
	{
		std::cout<< x << " , " << y <<std::endl;
	}
};

int main()
{
	const Point p(1,1);
	p.x = 10;     //error 값 바꿀 수 없음
	p.set(10,20); //error 값 바꿀 수 없음
	p.print(); // error

	return 0;
}

위 코드에서 객체 p 는 const object 로 선언되었습니다. 따라서 내부 멤버 변수인 x 값을 직접 변경하거나, 변수 값을 변경하는 기능이 구현된 set함수를 호출할 경우 error 가 발생합니다.
그런데 print 함수는 값을 변경하지 않음에도 호출하지 못합니다.
그 이유는 p이 상수 객체이므로 호출하는 함수 또한 상수함수임이 보장되어야 하기 때문입니다.
이것을 보장하기 위해, 멤버함수를 const 선언 해줌으로써 컴파일러가 해당 함수가 변수 값을 변경하지 않는 const 함수라는 것을 알수 있도록 해주면 됩니다.

사실, 객체의 상태를 변경하지 않는 '모든' 멤버함수는 (getXXX 류), 반드시 const 멤버함수가 되어야 합니다.

#include <iostream>


struct Rect
{
	int ox, oy, width, height;

	Rect(int x= 0, int y= 0, int w= 0, int h = 0): ox(x), oy(y), width(w), height(h){}

	int getArea() const { return width*height;}
};


void foo(const Rect& r) // call by value overhaed --> const & 가 좋음
{
	int n = r.getArea();  
}
int main()
{

	Rect r(0,0, 10, 10);

	int n= r.getArea();

	foo(r);
	return 0;
}

위 예제는 getArea 함수가 const 선언 되어야 하는 이유에 대해 설명하는 코드 입니다.
foo() 라는 함수에서 Rect 의 인스턴스를 통해 getArea 함수를 호출하는 경우를 생각해봅시다.
이때 오버헤드 측면에서 call by value 형태로 인자를 받아오는 것보다는, const 객체 참조로 받는 것이 타당합니다.
이 과정에서 r이 '상수 객체'로서 복사(?) 되므로 getArea() 가 반드시 const 선언 되어있어야 r.getArea()를 호출 할 수 있게 됩니다.

논리적 상수성

Case1. mutable 이용

#include <iostream>
#include <stdio.h>

class Point
{
private:
	int x, y;
	// mutable 멤버 변수 : 상수 멤버함수 안에서도 값 변경 가능
	mutable char cache[16];
	mutable bool cache_valid = false;

public:	
	Point(int a = 0, int b= 0) : x(a), y(b) {}

	const char* toString() const// 상수 멤버함수여야 하는 이유
	{		
		if(cache_valid == false){
			sprintf(cache,"%d, %d", x,y );  // 멤버함수(cache, cache_valid를 변경할 수 없음)
			cache_valid = true;
		}
		return cache; 
	}
};

위 코드 예제는 sprintf 의 오버헤드가 크다고 가정하고, cache 값이 변경됐을 경우에만 버퍼를 새롭게 써서 리턴하는 구조를 가져가는 형태로 구현을 한 것입니다.
그런데 toString 함수는 const 함수로 내부에서 멤버 변수들인 cache 및 cache_valid 값을 변경할 수 없습니다.
이 때, 이 두 변수들을 mutable 로 선언해주면, const 함수 내에서도 값을 변경할 수 있게 됩니다.
이렇게 함으로써 const 함수를 유지하면서도 내부적으로 변경이 필요한 변수들의 값을 바꿀 수 있습니다.

Case2. 포인터 이용

struct Cache
{
	char cache[16];
	bool cache_valid = false;
};
class Point
{
private:
	int x, y;
	Cache* pCache;
public:	
	Point(int a = 0, int b= 0) : x(a), y(b) {
		pCache = new Cache;
	}
	~Point(){
		delete pCache;
	}
	const char* toString() const// 상수 멤버함수여야 하는 이유
	{
 		if(pCache->cache_valid == false){
			sprintf(pCache->cache,"%d, %d", x,y );  // 멤버함수(cache, cache_valid를 변경할 수 없음)
			pCache->cache_valid = true;
		}
		return pCache->cache; 
	}
};

const 함수 내에 일부 변수를 변경하고자 할때 사용할 수 있는 두번째 방법은, 변경이 필요한 변수들을 별도 자료구조(Cache)에 담아두고, 이를 가리키는 포인터를 클래스 멤버 변수로 선언하는 것입니다.
이 객체가 생성자에서 Cache 인스턴스를 할당하고, const 함수 내에서는 이 인스턴스를 통해서 변수에 접근 및 변경을 할 수 있습니다.

const return

const를 반환하면, 반환된 값이 수정되지 않도록 보장합니다. 이는 다른 함수나 코드에서 반환된 값을 수정하는 것을 방지하므로 코드 안정성을 높이는 데 도움이 됩니다. 또한, 반환된 값을 const로 선언함으로써, 해당 값을 수정하는 코드가 컴파일러에서 에러로 처리되므로 유지 보수성을 높이는 데 도움이 됩니다.

또한, const를 반환하면 임시 객체에 대한 복사를 피할 수 있습니다. 예를 들어, 다음과 같은 함수가 있다고 가정해 봅시다.

const string getGreeting() {
  return "Hello";
}

이 함수가 호출되면, 문자열 "Hello"를 반환하는 임시 객체가 생성됩니다. 이 객체는 const로 반환되기 때문에, 함수 외부에서 수정될 수 없습니다. 만약 반환 값이 const가 아니라면, 임시 객체가 생성되는 것 외에도, 복사 생성자가 호출되어 복사본이 생성되어야 하므로 성능 저하를 초래할 수 있습니다.따라서, C++에서 const를 반환하는 것은 코드의 안정성, 유지 보수성, 성능 향상 등 여러 가지 이점을 제공합니다.

다른 예제를 살펴보겠습니다.

class Car {
public:
  const Engine& getEngine() const {
    return engine;
  }

private:
  Engine engine;
};

Car 클래스는 Engine 클래스의 객체를 포함하고 있습니다.
getEngine() 함수는 const 로 선언되어 있으며, Engine 객체를 반환합니다.
이 함수는 const 로 선언되었기 때문에 Car 객체가 const 로 선언되었을 때 호출될 수 있습니다.

const Car myCar;
const Engine& myEngine = myCar.getEngine();

위 코드에서 myCar는 const로 선언되었으므로, getEngine() 함수는 const 버전이 호출됩니다. getEngine() 함수가 반환하는 Engine 객체는 const로 선언되어 있으므로, myEngine 변수도 const로 선언되어야 합니다.
이렇게 함으로써, myEngine 객체가 수정되지 않도록 보장됩니다.
만약 getEngine() 함수가 const를 반환하지 않는다면, myCar 객체가 const로 선언되었을 때 getEngine() 함수를 호출할 수 없으며, myEngine 변수를 const로 선언하지 않으면 myEngine 객체가 수정될 수 있습니다.

따라서, const를 반환하는 함수를 사용함으로써 코드의 안정성과 유지 보수성을 높일 수 있습니다.

const pointer

C++에서 const 포인터는 포인터 자체가 변경될 수 없다는 것을 나타냅니다. 즉, 포인터가 가리키는 메모리의 값을 변경할 수는 있지만, 포인터가 가리키는 주소 자체는 변경할 수 없습니다.

const 포인터를 사용하면, 코드 안정성과 유지 보수성을 높일 수 있습니다. 예를 들어, 다음과 같은 코드를 생각해봅시다

void printValues(const int* values, int size) {
  for (int i = 0; i < size; ++i) {
    cout << values[i] << " ";
  }
}

위 코드에서 values 매개변수는 const int*로 선언되어 있습니다. 이는 values 포인터가 가리키는 메모리의 값을 변경할 수 있지만, values 포인터가 가리키는 주소 자체는 변경할 수 없다는 것을 나타냅니다.
이렇게 함으로써, printValues() 함수는 values 포인터를 통해 전달된 값들을 변경하지 않으므로, 호출한 쪽에서 전달한 값을 보존할 수 있습니다. 또한, const int* 타입을 사용하면, 잘못된 포인터 연산이나 잘못된 메모리 참조 등과 같은 문제를 방지할 수 있습니다.

또한, const 포인터는 포인터를 상수로 취급할 때도 유용합니다. 다음과 같은 예를 생각해보세요.

int value = 10;
const int* const pValue = &value;

위 코드에서 pValue는 const int* const로 선언되어 있습니다.

이는 pValue 포인터가 가리키는 주소 자체와, pValue 포인터가 가리키는 메모리의 값을 변경할 수 없다는 것을 나타냅니다.

이렇게 함으로써, pValue는 상수 포인터가 되어, 가리키는 값을 변경할 수 없으므로, 값이 변경되지 않도록 보장할 수 있습니다

부담 드리고 싶지 않아요 / 할지 고민이야 / ~것이 낫다 영어로

꼬북칩조아 — Mon, 27 Mar 2023 07:21:10 +0900

'부담'과 관련된 표현들

#1. 부담 갖지 마세요

(부담갖지 말고 편하게 해도 된다 라고 전달하려고 할때)

No pressure

Don't worry about it

A: 죄송하지만 사진좀 찍어주실수 있으실까요?

B: 아..제가 똥손이라..

A: 오 부담갖지 마세요. 그냥 저희가 사진에 담기기만 하면돼요

A: Excuse me. Could you take a picture of us, please ?

B: Oh, I don't know. I take horrible pictures

A: Oh, no pressure/dont' worry about it. We just want a picture with all of us in it

#2. (괜히 나때문에) 부담드리고 싶지 않아요

(예를 들면, 타지로 여행갔는데 지인으로부터 호텔말고 자기 집에와서 묵으라고 제안받았을 때)

(내가 상대를 번거롭게 만드는 것 같을 때)

A: I don't want to bother you (방해하고 싶지 않다 라는 뉘앙스)

B: It's no bother

(더 적절한 표현)

A: I don't want to impose

B: It's not an imposition

만약 그냥 거절하려면 (아니에요. 그건 아니죠)

No. I couldn't do that

could : 그렇게 하고 싶어도 그럴 순 없지.

A: Why don't you stay for dinner ? please, stay for dinner

B : Oh, no. I couldn't do that 또는 I don't want to impose

+ 만약 B 가 제안에 우물쭈물 고민하고 있을때, A가 부담갖지 마세요라는 표현으로 I don't wanna impose 라고 표현 가능

* 추가설명 :

그 외에 부담스럽다는 의미로 쓰이는 표현들 :

1. make <one> feel uncomfortable :

(누가 부담스럽게 쳐다 본다거나 부담스러운 질문을 할 때)

→ He made everyone at table very uncomfortable with his inappropriate questions.

2. breathe down <one's> neck (pressure와 비슷한 의미로 누구에게 압박을 준다는 의미에서 부담을 준다는 의미로 활용)

→ I can focus on my work a lot better without my boss constantly breathing down my neck!

3. You don't have to. / You can say no. → 안해도 돼 / 싫다고 해도 돼

(아주 편한 사이에 / 극히 캐쥬얼하게 표현하는 것이 더 적합한 상황에서)

* burden은 '부담'보다는 '짐'의 어감에 더 가깝게 쓰이는 경우가 많움

예) 가족에게 짐이 되고 싶지 않다 - I don't want to be a burden to my family.

고민에 대한 간접의문문 표현

어떻게 할지 (하는 것이 좋을지)

..할지 말지.. (하는 것이 좋을지 아닐지)

나 일찍 자는게 좋겠어

☞ I should go to bed early (일찍 자야돼라는 느낌보다는 일찍 자는게 좋겠어)

나 일찍자는게 좋을까? (의문문)

☞ Should I go to bed early ?

내가 일찍 자는 것이 좋을지 모르겠어 (간접의문문; ~ 하는 것이 좋을지 고민이야)

☞ I'm not sure if i should go to bed early

걔한테 이거에 대해 얘기 하는 것이 좋을지 고민이야 (잘 모르겠어)

☞ I'm not sure if i should tell him about this

이거에 대해서 걔한테 지금 얘기할지 아니면 기다릴지 고민이야

☞ I'm not sure if i should tell him about this now or wait

새 폰을 지금 살지 아니면 새로운 모델이 나올때까지 기다릴지 고민이야

☞ I'm not sure if i should buy a new smartphone now or wait until a new model comes out

☞ I'm trying to decide if i should buy a new smartphone now or wait until a new model comes out

(좀 더 직설적인 표현, 결정하려고 노력하고 있다. 즉, 고민중이다)

새 폰을 지금 살지 아니면 새로운 모델이 나올때까지 기다릴지 계속 고민중이야 ( 오랜시간 지속되어 오고 있다면 )

☞ I'm still trying to decide if i should buy a new smartphone now or wait until a new model comes out

걔한테 뭐라고 할까?

☞ What should I tell him ?

걔한테 뭐라고 얘길 해줄지 고민이야

☞ I'm not sure what I should tell him

어느 것을 사는 것이 좋을지 (아직) 고민이야

☞ I'm not sure which one I should buy

☞ I'm (still) tryting to decide which one I should buy

더 낫다 (it's better)

당신이 뭔가 잘못을 했으면, 그냥 그것을 인정하고 사과하는 것이 항상 낫다 (~하는게 낫다; 일반화)

☞ If you did something wrong or made a mistake, it's always better to just admit it and apologize

A: 나 차 세차나 하러 갈까? 진짜 더럽네 (get car washed : 사역; 세차 맡기는 느낌)

B: 담주까지 기다리는게 나을듯 (일반화해서 말하는 것은 어색함). 이번 주 내내 비올거니까

B: 담주까지 기다리는게 나을수도 있을듯(좀 더 약하게). 이번 주 내내 비올거니까

☞ A: May be I should get my car washed. It's really dirty

☞ B: (I think) It would be better (for you) to wait unitl next week. because it's going to keep raining all week.

☞ B: (I think) It could/might be better (for you) to wait unitl next week. because it's going to keep raining all week.

*keep ~ing : 계속 ~ (한 상태) 하다

*all week/ this week : 이번 주 내내

[C++] shared_ptr을 사용하는 이유

꼬북칩조아 — Sun, 26 Mar 2023 20:54:33 +0900

shared_ptr 을 사용하는 이유

C++에서 메모리 누수(memory leak)를 방지하고, 안전하게 객체를 공유하는데 사용됩니다.

C++에서는 메모리를 수동으로 할당하고 해제하는 것이 일반적이지만, 이러한 작업을 관리하는 것은 어려울 수 있습니다.

특히, 동적으로 할당된 메모리를 사용하는 경우, 메모리를 해제하는 것을 잊어버리면 메모리 누수가 발생할 수 있습니다.

shared_ptr은 동적으로 할당된 메모리를 관리하는 스마트 포인터(Smart Pointer) 중 하나입니다.

스마트 포인터는 C++에서 메모리 관리를 자동화하는데 사용되며, 메모리 누수를 방지할 수 있습니다.

shared_ptr은 객체에 대한 공유 소유권(shared ownership)을 제공합니다.

이는 동일한 객체를 여러 개의 shared_ptr에서 공유할 수 있으며, 모든 shared_ptr이 삭제될 때 객체가 자동으로 해제된다는 것을 의미합니다.

이러한 공유 소유권을 제공하는 것은 객체에 대한 참조를 안전하게 공유하고, 객체가 더 이상 필요하지 않을 때 자동으로 삭제하여 메모리 누수를 방지하는 데 도움이 됩니다.

또한, shared_ptr은 일반적으로 new 및 delete 연산자를 사용하여 메모리를 동적으로 할당하고 해제하는 것보다 안전합니다. shared_ptr을 사용하면 자동으로 메모리가 해제되므로 메모리 누수 및 다른 문제가 발생할 가능성이 줄어듭니다.

shared_ptr 의 원리

shared_ptr은 객체에 대한 공유 소유권(shared ownership)을 제공하며, 모든 shared_ptr이 삭제될 때 객체가 자동으로 해제됩니다.

shared_ptr의 작동 방식은 참조 계수(reference counting)를 사용합니다.

즉, shared_ptr은 객체에 대한 참조를 가지고 있으며, 객체를 참조하는 shared_ptr의 개수를 계산합니다.

이러한 개수를 참조 계수라고 합니다. 참조 계수가 0이면 객체가 자동으로 해제됩니다.

객체를 생성할 때, shared_ptr은 객체와 함께 참조 계수를 생성합니다.

새로운 shared_ptr이 객체를 참조할 때마다, 참조 계수를 증가시킵니다.

shared_ptr이 객체에 대한 참조를 해제하면, 참조 계수를 감소시킵니다.

참조 계수가 0이 되면, shared_ptr이 객체를 삭제하고 참조 계수도 함께 삭제합니다.

shared_ptr은 여러 개의 shared_ptr에서 객체를 공유할 수 있습니다.

이때 shared_ptr은 동일한 참조 계수를 공유하며, 모든 shared_ptr이 삭제될 때 참조 계수가 0이 되어 객체가 자동으로 해제됩니다.

shared_ptr은 std::make_shared 함수를 사용하여 생성할 수 있습니다.

이 함수는 동적으로 할당된 메모리를 자동으로 해제하므로, 메모리 누수와 관련된 문제를 방지할 수 있습니다.

예를 들어, 다음과 같은 코드를 사용하여 shared_ptr을 생성할 수 있습니다.

#include <memory>

int main() {
    // 객체를 생성하여 shared_ptr로 래핑합니다.
    std::shared_ptr<int> ptr1(new int(42));

    // make_shared 함수를 사용하여 shared_ptr을 생성합니다.
    std::shared_ptr<int> ptr2 = std::make_shared<int>(42);

    return 0;
}

코드에서 ptr1은 new 연산자를 사용하여 메모리를 동적으로 할당합니다.

반면에 ptr2는 std::make_shared 함수를 사용하여 메모리를 동적으로 할당합니다. 이러한 차이점은 메모리 누수 및 다른 문제를 방지하는 데 중요합니다

shared_ptr을 사용하여 객체를 공유하는 방법

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "MyClass 생성자 호출" << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass 소멸자 호출" << std::endl;
    }
};

int main() {
    // MyClass 객체를 생성하여 shared_ptr로 래핑합니다.
    std::shared_ptr<MyClass> ptr1(new MyClass);

    // ptr1과 동일한 MyClass 객체를 참조하는 또 다른 shared_ptr을 만듭니다.
    std::shared_ptr<MyClass> ptr2(ptr1);

    // ptr1과 ptr2 모두가 객체를 참조하고 있습니다.
    std::cout << "ptr1.use_count(): " << ptr1.use_count() << std::endl;
    std::cout << "ptr2.use_count(): " << ptr2.use_count() << std::endl;

    // ptr1을 해제합니다.
    ptr1.reset();

    // ptr1이 해제되었으므로 ptr2만 객체를 참조하고 있습니다.
    std::cout << "ptr1이 해제되었으므로 ptr2만 객체를 참조합니다." << std::endl;
    std::cout << "ptr2.use_count(): " << ptr2.use_count() << std::endl;

    return 0;
}

위 코드에서 MyClass는 간단한 클래스로, 객체가 생성될 때 메시지를 출력하고 객체가 삭제될 때 메시지를 출력합니다.

main 함수에서는 MyClass 객체를 생성하여 shared_ptr로 래핑합니다.

그런 다음, ptr1과 동일한 객체를 참조하는 또 다른 shared_ptr인 ptr2를 만듭니다.

이후, ptr1과 ptr2의 use_count 함수를 호출하여 객체를 참조하는 shared_ptr의 개수를 확인합니다.

ptr1을 해제한 후 ptr2의 use_count를 다시 확인합니다. ptr1이 해제되었으므로 ptr2만 객체를 참조하고 있습니다.

이 예제는 shared_ptr이 객체에 대한 공유 소유권을 제공하는 방법을 보여줍니다.

또한, shared_ptr의 참조 계수를 확인하여 객체가 얼마나 많은 shared_ptr에서 참조되고 있는지 확인할 수 있습니다.

shared_ptr을 사용하여 복잡한 상호 참조 구조를 만드는 예제

#include <iostream>
#include <memory>

class B;
class C;

class A {
public:
    A() {
        std::cout << "A 생성자 호출" << std::endl;
    }
    ~A() {
        std::cout << "A 소멸자 호출" << std::endl;
    }
    void set_b(std::shared_ptr<B> b) {
        b_ = b;
    }
    void set_c(std::shared_ptr<C> c) {
        c_ = c;
    }
private:
    std::shared_ptr<B> b_;
    std::shared_ptr<C> c_;
};

class B {
public:
    B() {
        std::cout << "B 생성자 호출" << std::endl;
    }
    ~B() {
        std::cout << "B 소멸자 호출" << std::endl;
    }
    void set_a(std::shared_ptr<A> a) {
        a_ = a;
    }
    void set_c(std::shared_ptr<C> c) {
        c_ = c;
    }
private:
    std::shared_ptr<A> a_;
    std::shared_ptr<C> c_;
};

class C {
public:
    C() {
        std::cout << "C 생성자 호출" << std::endl;
    }
    ~C() {
        std::cout << "C 소멸자 호출" << std::endl;
    }
    void set_a(std::shared_ptr<A> a) {
        a_ = a;
    }
    void set_b(std::shared_ptr<B> b) {
        b_ = b;
    }
private:
    std::shared_ptr<A> a_;
    std::shared_ptr<B> b_;
};

int main() {
    std::shared_ptr<A> a(new A);
    std::shared_ptr<B> b(new B);
    std::shared_ptr<C> c(new C);

    a->set_b(b);
    a->set_c(c);

    b->set_a(a);
    b->set_c(c);

    c->set_a(a);
    c->set_b(b);

    std::cout << "a.use_count(): " << a.use_count() << std::endl;
    std::cout << "b.use_count(): " << b.use_count() << std::endl;
    std::cout << "c.use_count(): " << c.use_count() << std::endl;

    return 0;
}

다음 예제는 두 개의 클래스 Person과 Address를 정의하고, Person 객체가 Address 객체를 참조하도록 구현합니다.

Person 객체와 Address 객체를 모두 shared_ptr로 관리합니다

#include <iostream>
#include <memory>
#include <string>

class Address {
public:
    Address(const std::string& street, const std::string& city) : m_street(street), m_city(city) {
        std::cout << "Address 생성자 호출: " << m_street << ", " << m_city << std::endl;
    }
    ~Address() {
        std::cout << "Address 소멸자 호출: " << m_street << ", " << m_city << std::endl;
    }
    std::string getStreet() const {
        return m_street;
    }
    std::string getCity() const {
        return m_city;
    }
private:
    std::string m_street;
    std::string m_city;
};

class Person {
public:
    Person(const std::string& name, const std::string& street, const std::string& city) : m_name(name), m_address(std::make_shared<Address>(street, city)) {
        std::cout << "Person 생성자 호출: " << m_name << std::endl;
    }
    ~Person() {
        std::cout << "Person 소멸자 호출: " << m_name << std::endl;
    }
    std::string getName() const {
        return m_name;
    }
    std::shared_ptr<Address> getAddress() const {
        return m_address;
    }
private:
    std::string m_name;
    std::shared_ptr<Address> m_address;
};

int main() {
    // 두 개의 Person 객체를 생성합니다.
    std::shared_ptr<Person> person1(new Person("Alice", "123 Main St", "Anytown"));
    std::shared_ptr<Person> person2(new Person("Bob", "456 Elm St", "Anytown"));

    // person1과 person2가 참조하는 Address 객체를 출력합니다.
    std::cout << "person1이 참조하는 Address 객체: " << person1->getAddress()->getStreet() << ", " << person1->getAddress()->getCity() << std::endl;
    std::cout << "person2가 참조하는 Address 객체: " << person2->getAddress()->getStreet() << ", " << person2->getAddress()->getCity() << std::endl;

    // person1과 person2의 Address 객체가 같은지 확인합니다.
    if (person1->getAddress() == person2->getAddress()) {
        std::cout << "person1과 person2가 같은 Address 객체를 참조합니다." << std::endl;
    } else {
        std::cout << "person1과 person2가 다른 Address 객체를 참조합니다." << std::endl;
    }

    // person1을 삭제합니다.
    person1.reset();

    // person1이 참조하던 Address 객체를 출력합니다.
    if (person2->getAddress()) {
        std::cout << "person1이 참조하던 Address 객체: " << person2->getAddress()->getStreet() << ", " << person2->getAddress()->getCity() << std::endl;
    } else {
        std::cout << "person1이 참조하던 Address 객체

person1이 참조하던 Address 객체는 더 이상 참조되지 않으므로, 메모리에서 해제됩니다.

이 때, Address 클래스의 소멸자가 호출되고, 해당 객체가 속한 Person 객체도 메모리에서 해제됩니다.

person2는 여전히 Address 객체를 참조하고 있으므로, person2의 소멸자가 호출될 때까지 해당 Address 객체는 유효합니다.

shared_ptr은 복잡한 객체들을 관리하는 데 매우 편리한 기능을 제공합니다.

그러나 여러 shared_ptr이 하나의 객체를 참조하는 경우, 객체가 메모리에서 해제되는 시점이 예상과 다를 수 있으므로 주의해야 합니다. 또한, shared_ptr을 사용할 때는 서로 다른 스레드에서 동시에 접근하지 않도록 주의해야 합니다

게임 엔진에서 리소스 관리

게임 엔진에서 리소스 관리에 shared_ptr을 사용합니다.

게임 엔진에서는 이미지, 사운드, 모델 등 다양한 리소스를 로드하고 사용하는데, 이러한 리소스는 게임이 종료될 때까지 메모리에 유지되어야 하지만, 게임의 레벨이나 씬이 바뀔 때마다 리소스가 필요한 만큼만 로드하고, 사용이 끝나면 메모리에서 해제되어야 합니다.

shared_ptr은 리소스가 사용 중인지 아닌지를 추적할 수 있으므로, 여러 개의 객체에서 공유하며 사용하는 리소스를 안전하게 관리할 수 있습니다. 또한, shared_ptr은 객체가 더 이상 참조되지 않을 때 자동으로 메모리에서 해제되므로, 메모리 누수를 방지할 수 있습니다.

이러한 이유로, 많은 게임 엔진에서는 shared_ptr을 사용하여 리소스를 관리하고 있습니다. 예를 들어, Unreal Engine에서도 TSharedPtr이라는 이름으로 shared_ptr을 사용하여 객체를 관리합니다.

우선, Resource 클래스를 정의합니다.

이 클래스는 리소스의 기본 형태를 나타내며, 파일 이름과 크기를 멤버 변수로 가지고 있습니다.

class Resource {
public:
    Resource(const std::string& name, int size)
        : m_name(name), m_size(size) {}

    std::string getName() const { return m_name; }
    int getSize() const { return m_size; }

private:
    std::string m_name;
    int m_size;
};

다음으로, ResourceHolder 클래스를 정의합니다. 이 클래스는 리소스를 로드하고 관리하는 역할을 합니다.

ResourceHolder 클래스는 std::map을 사용하여 리소스를 이름으로 관리합니다.

class ResourceHolder {
public:
    std::shared_ptr<Resource> getResource(const std::string& name) {
        auto iter = m_resourceMap.find(name);
        if (iter != m_resourceMap.end()) {
            return iter->second;
        }
        else {
            // Load the resource from file
            std::shared_ptr<Resource> resource = std::make_shared<Resource>(name, 100);
            m_resourceMap[name] = resource;
            return resource;
        }
    }

private:
    std::map<std::string, std::shared_ptr<Resource>> m_resourceMap;
};

getResource 함수는 먼저 std::map에서 해당 이름의 리소스를 찾습니다. 이미 로드되어 있는 경우에는 해당 리소스에 대한 shared_ptr을 반환하고, 아직 로드되어 있지 않은 경우에는 파일에서 리소스를 로드하고 shared_ptr을 생성하여 std::map에 추가합니다.

마지막으로, main 함수에서 ResourceHolder 클래스를 사용하여 리소스를 로드합니다.

int main() {
    ResourceHolder resourceHolder;

    std::shared_ptr<Resource> res1 = resourceHolder.getResource("image1.png");
    std::shared_ptr<Resource> res2 = resourceHolder.getResource("sound1.wav");
    std::shared_ptr<Resource> res3 = resourceHolder.getResource("image1.png");

    std::cout << "Resource 1: " << res1->getName() << ", size: " << res1->getSize() << std::endl;
    std::cout << "Resource 2: " << res2->getName() << ", size: " << res2->getSize() << std::endl;
    std::cout << "Resource 3: " << res3->getName() << ", size: " << res3->getSize() << std::endl;
    std::cout << "res1 and res3 are " << (res1 == res3 ? "same" : "different") << std::endl;

    return 0;
}

main 함수에서는 ResourceHolder 클래스의 getResource 함수를 사용하여

image1.png와 sound1.wav 파일에서 리소스를 로드합니다.

image1.png 파일은 이미 한 번 로드되어 있기 때문에 getResource 함수는 새로운 shared_ptr을 생성하지 않고,

이미 로드된 리소스에 대한 shared_ptr을 반환합니다

주의사항

shared_ptr을 사용할 때 주의해야 할 몇 가지 내용이 있습니다.

순환 참조(circular reference) 문제: shared_ptr은 reference counting 방식을 사용하기 때문에 객체가 서로를 참조하는 경우 순환 참조 문제가 발생할 수 있습니다. 이런 경우에는 weak_ptr을 사용하거나, 참조 구조를 재설계해야 합니다.
shared_ptr에 raw pointer를 대입하지 않기: shared_ptr에 raw pointer를 대입하게 되면, 두 개 이상의 shared_ptr이 같은 객체를 참조할 때, 객체가 제대로 해제되지 않는 문제가 발생할 수 있습니다. 대신, make_shared() 함수를 사용하거나 shared_ptr의 생성자에 raw pointer를 전달하는 것이 좋습니다.
C++11에서는 std::enable_shared_from_this를 상속받아야 shared_ptr의 안전한 사용이 가능합니다. 이 클래스를 상속한 객체는 자신을 참조하는 shared_ptr을 생성할 수 있습니다.
사용자 정의 deleter를 지정할 수 있습니다. shared_ptr은 reference counting을 이용하여 객체를 관리하지만, 사용자가 직접 메모리 할당을 하고 해제해야 하는 경우가 있습니다. 이때 사용자 정의 deleter를 지정하여 메모리 할당과 해제를 처리할 수 있습니다.

[C++] google test - gmock #2

꼬북칩조아 — Sat, 25 Mar 2023 00:04:27 +0900

리턴 값을 강제로 지정하는 예제

class MockFoo : public Foo {
 public:
  MOCK_METHOD(int, GetSize, (), (const, override));
};

TEST(MyMockTest, ReturnsTest) {
  MockFoo mock_foo;
  ON_CALL(mock_foo, GetSize()).WillByDefault(Return(42));
  EXPECT_EQ(42, mock_foo.GetSize());
}

2. 입력 인자를 확인하는 예제

class MockFoo : public Foo {
 public:
  MOCK_METHOD(int, Add, (int x, int y), (override));
};

TEST(MyMockTest, ArgumentTest) {
  MockFoo mock_foo;
  EXPECT_CALL(mock_foo, Add(4, 5)).WillOnce(Return(9));
  EXPECT_EQ(9, mock_foo.Add(4, 5));
}

3. 입력 인자를 변경하는 예제

class MockFoo : public Foo {
 public:
  MOCK_METHOD(int, Sum, (int x, int y), (override));
};

TEST(MyMockTest, ArgumentChangeTest) {
  MockFoo mock_foo;
  int x = 2;
  int y = 3;
  EXPECT_CALL(mock_foo, Sum(_, _)).WillOnce(DoAll(
      SaveArg<0>(&x), SaveArg<1>(&y),
      Return(0)));
  mock_foo.Sum(1, 2);
  EXPECT_EQ(1, x);
  EXPECT_EQ(2, y);
}

4. 순서를 지정하는 예제

class MockFoo : public Foo {
 public:
  MOCK_METHOD(int, GetSize, (), (const, override));
  MOCK_METHOD(void, SetSize, (int size), (override));
};

TEST(MyMockTest, OrderTest) {
  MockFoo mock_foo;
  EXPECT_CALL(mock_foo, GetSize()).WillOnce(Return(42));
  EXPECT_CALL(mock_foo, SetSize(84)).After(
      EXPECT_CALL(mock_foo, GetSize()).WillOnce(Return(42)));
  mock_foo.GetSize();
  mock_foo.SetSize(84);
}

5. 예외를 던지는 예제

class MockFoo : public Foo {
 public:
  MOCK_METHOD(void, Func, (), (override));
};

TEST(MyMockTest, ExceptionTest) {
  MockFoo mock_foo;
  EXPECT_CALL(mock_foo, Func()).WillOnce(
      Throw(std::runtime_error("error")));
  EXPECT_THROW(mock_foo.Func(), std::runtime_error);
}

6. 특정 횟수만큼 호출하는 예제

class MockFoo : public Foo {
 public:
  MOCK_METHOD(void, Func, (), (override));
};

TEST(MyMockTest, TimesTest) {
  MockFoo mock_foo;
  EXPECT_CALL(mock_foo, Func()).Times(2);
  mock_foo.Func();
  mock_foo.Func();
}

7. 다른 함수를 호출하는 예제

class MockFoo : public Foo {
 public:
  MOCK_METHOD(void, Func1, (), (override));
  MOCK_METHOD(void, Func2, (), (override));
};

TEST(MyMockTest, CallOtherFunctionTest) {
  MockFoo mock_foo;
  EXPECT_CALL(mock_foo, Func1())
      .WillOnce(InvokeWithoutArgs([&mock_foo]() {
        mock_foo.Func2();
      }));
  EXPECT_CALL(mock_foo, Func2());
  mock_foo.Func1();
}

gmock test 예제

함수 인자 검증 (Argument Verification)

TEST(MathTest, DivideByZero) {
  MockFunction<double(double, double)> mock_divide;

  EXPECT_CALL(mock_divide, Call(10, 0))
      .WillOnce(Throw(std::runtime_error("Divide by zero")));

  Math math;
  EXPECT_THROW(math.Divide(10, 0, &mock_divide), std::runtime_error);
}

이 예제에서는 Math 클래스의 Divide 함수에서 인자로 받은 두 숫자를 나누는데, 만약 두 번째 인자가 0이면 std::runtime_error 예외를 던지도록 되어 있 음

이 함수가 제대로 작동하는지 검증하기 위해서, MockFunction을 이용해 인자로 10과 0을 전달했을 때 std::runtime_error 예외를 던지는 것을 확인

2. 다수의 반환값 (Multiple Return Values)

class MockDatabase : public Database {
 public:
  MOCK_METHOD(std::string, LookupName, (int id), (override));

 private:
  std::map<int, std::string> id_to_name_ = {
      {1, "Alice"},
      {2, "Bob"},
      {3, "Charlie"},
      {4, "Dave"},
      {5, "Eve"},
  };
};

TEST(LookupTest, ReturnsNameForValidId) {
  MockDatabase mock_database;
  EXPECT_CALL(mock_database, LookupName(1))
      .WillOnce(Return("Alice"));

  NameLookup name_lookup(&mock_database);
  std::string name = name_lookup.GetName(1);
  ASSERT_EQ("Alice", name);
}

이 예제에서는 Database 클래스를 상속받은 MockDatabase 클래스를 이용해 특정 id에 해당하는 이름을 반환하는 LookupName 함수를 테스트

EXPECT_CALL을 이용해 1에 해당하는 이름이 "Alice"인 것을 확인

3. 구글 테스트와 같이 사용하기 (Integration with Google Test)

TEST_F(MyTest, TestConnection) {
  MockConnection conn;
  ON_CALL(conn, Connect())
      .WillByDefault(Return(true));
  ON_CALL(conn, Disconnect())
      .WillByDefault(Return(true));

  MyObject obj(&conn);

  EXPECT_TRUE(obj.IsConnected());
  obj.DoSomething();
  EXPECT_TRUE(obj.IsConnected());
  obj.DoSomethingElse();
  EXPECT_TRUE(obj.IsConnected());
}

이 예제에서는 MyObject 클래스가 MockConnection을 이용해 연결하는지 여부를 검증

ON_CALL을 이용해 Connect()와 Disconnect() 함수가 호출될 때 각각 true를 반환하도록 설정한 후,

MyObject 객체를 생성하여 IsConnected() 함수의 반환값이 true인지 여부를 확인

이 예제는 구글 테스트(Google Test)와 함께 사용될 때 많이 쓰임

예제

#include <iostream>
#include <string>
#include <vector>
#include "gmock/gmock.h"

using namespace std;
using namespace testing;

// 모의 클래스 정의
class MyMockClass {
public:
    MOCK_METHOD2(MyMethod, int(int arg1, const string& arg2));
};

// 테스트 클래스 정의
class MyTestClass : public Test {
public:
    void SetUp() override {
        // 모의 클래스 객체 생성
        my_mock_object_ = new MyMockClass;
        // 모의 클래스 객체와 함수 연결
        ON_CALL(*my_mock_object_, MyMethod(_, _))
            .WillByDefault(Return(0));
    }

    void TearDown() override {
        delete my_mock_object_;
    }

protected:
    MyMockClass* my_mock_object_;
};

// 테스트 케이스 1
TEST_F(MyTestClass, Test1) {
    // 모의 함수 호출
    EXPECT_CALL(*my_mock_object_, MyMethod(42, "Hello"))
        .WillOnce(Return(1));
    // 테스트
    ASSERT_EQ(my_mock_object_->MyMethod(42, "Hello"), 1);
}

// 테스트 케이스 2
TEST_F(MyTestClass, Test2) {
    // 모의 함수 호출
    EXPECT_CALL(*my_mock_object_, MyMethod(69, "World"))
        .WillOnce(Return(2));
    // 테스트
    ASSERT_EQ(my_mock_object_->MyMethod(69, "World"), 2);
}

// 테스트 케이스 3
TEST_F(MyTestClass, Test3) {
    // 모의 함수 호출
    EXPECT_CALL(*my_mock_object_, MyMethod(123, _))
        .WillOnce(Return(3));
    // 테스트
    ASSERT_EQ(my_mock_object_->MyMethod(123, "Whatever"), 3);
}

// 테스트 케이스 4
TEST_F(MyTestClass, Test4) {
    // 모의 함수 호출
    vector<pair<int, string>> args = {{1, "a"}, {2, "b"}, {3, "c"}};
    vector<int> ret_vals = {4, 5, 6};
    EXPECT_CALL(*my_mock_object_, MyMethod(_, _))
        .WillOnce(Return(ret_vals[0]))
        .WillOnce(Return(ret_vals[1]))
        .WillOnce(Return(ret_vals[2]));
    // 테스트
    for (size_t i = 0; i < args.size(); ++i) {
        ASSERT_EQ(my_mock_object_->MyMethod(args[i].first, args[i].second), ret_vals[i]);
    }
}

// 테스트 케이스 5
TEST_F(MyTestClass, Test5) {
    // 모의 함수 호출
    EXPECT_CALL(*my_mock_object_, MyMethod(_, _))
        .WillOnce(Return(1));
    // 테스트
    ASSERT_EQ(my_mock_object_->MyMethod(42, "Hello"), 1);
    ASSERT_EQ(my_mock_object_->MyMethod(69, "World"), 1);
}

int main(int argc, char** argv) {
    InitGoogleMock(&argc, argv);
    return RUN_ALL_TESTS();
}

예제3

class Bank {
public:
    virtual ~Bank() {}
    virtual void deposit(int amount) = 0;
};

class Customer {
public:
    Customer(Bank* bank) : bank_(bank) {}

    void deposit(int amount) {
        if (amount <= 0) {
            throw std::runtime_error("Invalid amount");
        }
        bank_->deposit(amount);
    }

private:
    Bank* bank_;
};

Customer 클래스는 다음과 같이 Bank 클래스를 멤버로 가지고 있음

Customer 객체가 Bank 객체의 deposit 메서드를 호출할 때, 다양한 오류 상황이 발생할 수 있음

이를 gmock을 활용해서 검증

먼저, Bank 클래스를 mocking

class MockBank : public Bank {
public:
    MOCK_METHOD(void, deposit, (int amount), (override));
};

다음으로, Customer 클래스의 deposit 메서드가 예상한 대로 작동하는지 검증해봅니다. 이때, Bank 클래스의 deposit 메서드를 호출할 때, 어떤 인자가 전달되는지에 대한 검증도 수행

TEST(CustomerTest, DepositSuccess) {
    MockBank bank;
    Customer customer(&bank);

    EXPECT_CALL(bank, deposit(100));

    customer.deposit(100);
}

이번에는 Customer 객체가 deposit 메서드를 호출할 때, 음수 값을 전달하는 경우가 발생하는지 검증해보겠습니다. 이를 위해서는 Bank 객체의 deposit 메서드가 호출되지 않아야 합니다

TEST(CustomerTest, DepositWithNegativeAmount) {
    MockBank bank;
    Customer customer(&bank);

    EXPECT_THROW(customer.deposit(-100), std::runtime_error);
    EXPECT_CALL(bank, deposit(_)).Times(0);
}

마지막으로, Bank 객체의 deposit 메서드에서 예외가 발생하는 경우도 검증해봅니다. 이를 위해서는 Customer 객체가 Bank 객체의 deposit 메서드를 호출할 때, 예외가 발생할 것임을 미리 알고 있어야 합니다.

TEST(CustomerTest, DepositThrowsException) {
    MockBank bank;
    Customer customer(&bank);

    EXPECT_CALL(bank, deposit(100)).WillOnce(
        [] (int amount) { throw std::runtime_error("Failed to deposit"); });

    EXPECT_THROW(customer.deposit(100), std::runtime_error);
}

위 예제에서는 gmock을 활용해서 Customer 객체가 Bank 객체의 deposit 메서드를 호출할 때, 발생할 수 있는 다양한 오류 상황을 검증

설명

어떤 프로그램이 Customer 객체를 생성합니다.
Customer 객체는 Bank 객체에 대한 참조자를 가지고 있습니다.
Customer 객체의 makeDeposit 메서드를 호출하면, Bank 객체의 deposit 메서드가 호출되어야 합니다.
Bank 객체의 deposit 메서드는 인자로 받은 금액을 해당 계좌에 입금합니다.
이때, Bank 객체가 인증되지 않은 경우에는 입금이 되지 않아야 합니다.

위의 상황을 검증하기 위해서는 다음과 같은 동작이 필요합니다.

Bank 객체를 모의(mock)합니다.
Bank 객체를 모의하면서, deposit 메서드가 호출될 때 인자로 넘어오는 값을 검증할 수 있도록 합니다.
Bank 객체를 모의하면서, deposit 메서드가 호출되기 전에 먼저 인증 과정을 거쳐야 한다는 것을 검증할 수 있도록 합니다.
Customer 객체를 생성합니다. 이때, 모의된 Bank 객체의 참조자를 Customer 객체에 전달합니다.
Customer 객체의 makeDeposit 메서드를 호출합니다. 이때, 모의된 Bank 객체의 deposit 메서드가 호출되어야 합니다.
모의된 Bank 객체에서 deposit 메서드의 인자로 넘어온 값을 검증합니다.
모의된 Bank 객체에서 인증 과정이 올바르게 진행되었는지 검증합니다.

이렇게 하면, Customer 객체가 Bank 객체의 deposit 메서드를 호출할 때 발생할 수 있는 다양한 오류 상황을 검증할 수 있습니다. 이를 위해서 gmock을 사용하면, 모의 객체를 쉽게 생성하고 다양한 동작을 검증할 수 있습니

[C++] google test - gmock #1

꼬북칩조아 — Fri, 24 Mar 2023 23:41:54 +0900

unit test 란

mocking 이란

mocking은 유닛 테스트에서 사용되는 기술 중 하나로, 의존성 있는 코드를 테스트할 때, 해당 의존성을 가짜 객체로 대체하여 테스트하는 것을 의미함

즉, 의존성 있는 코드를 호출할 때, 그 코드가 호출하는 객체를 대신해서 가짜 객체를 사용하여 호출하는 것

이 가짜 객체는 실제 객체와 동일한 인터페이스를 제공하지만, 미리 정의된 테스트 케이스에 따라서 적절한 결과를 반환

이렇게 하면 의존성이 있는 코드의 결과를 예측 가능하게 만들어

또한, 의존성이 있는 코드를 모의(mock) 객체로 대체하면, 해당 객체가 실제 시스템에 영향을 미치지 않고도 코드를 테스트할 수 있음

Queue라는 클래스가 있다고 가정하고, Queue가 의존하는 클래스인 Data라는 클래스를 mocking하는 예제

// Queue.h
#include "Data.h"

class Queue {
public:
    Queue(Data* data);
    int size();
private:
    Data* data_;
};

// Queue.cpp
#include "Queue.h"

Queue::Queue(Data* data) : data_(data) {}

int Queue::size() {
    return data_->getSize();
}

// MockData.h
#include "Data.h"
#include "gmock/gmock.h"

class MockData : public Data {
public:
    MOCK_METHOD(int, getSize, (), (override));
};

// QueueTest.cpp
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "Queue.h"
#include "MockData.h"

using ::testing::Return;

TEST(QueueTest, SizeTest) {
    MockData mock_data;
    Queue q(&mock_data);
    EXPECT_CALL(mock_data, getSize()).WillOnce(Return(3));
    ASSERT_EQ(q.size(), 3);
}

이 예제에서는 Queue 클래스가 Data 클래스에 의존하고 있음

그리고 QueueTest에서는 Queue의 size() 메소드를 테스트하고자 함

하지만, size() 메소드는 Data의 getSize() 메소드를 호출하기 때문에, Data 클래스에 의존하고 있는 상황

이를 해결하기 위해 MockData 클래스를 만들어 Data 클래스를 mocking

Queue 클래스에서는 생성자에서 Data 객체를 받아서 멤버 변수로 저장

size() 메소드에서는 Data 객체의 getSize() 메소드를 호출하여 반환값을 리턴

QueueTest에서는 MockData 객체를 생성하고, Queue 객체를 생성할 때 이를 전달

그리고 EXPECT_CALL 매크로를 사용하여, MockData 객체의 getSize() 메소드가 호출될 때 3을 반환하도록 지정

마지막으로 ASSERT_EQ 매크로를 사용하여 Queue 객체의 size() 메소드가 3을 반환하는지 확인

이렇게 Mocking을 통해, Queue 클래스가 Data 클래스에 의존하는 상황에서도 테스트를 수행할 수 있게됨

mocking을 사용하여 실제 데이터베이스에 접근하지 않고 데이터베이스를 대체하는 예제

예를 들어, 데이터베이스에서 사용자 정보를 가져와 로그인 인증을 수행하는 함수가 있는데,

이 함수는 데이터베이스에 직접 연결하여 쿼리를 실행하므로 테스트를 수행하는 데 시간이 많이 소요된다고 가정

이런 경우 mocking을 사용하여 데이터베이스에 연결하지 않고도 테스트를 수행할 수 있음

먼저 사용자 정보를 나타내는 User 클래스는 아래 처럼 디자인 해볼 수 있음

class User {
public:
    User(const std::string& name, const std::string& password) : name_(name), password_(password) {}
    const std::string& GetName() const { return name_; }
    const std::string& GetPassword() const { return password_; }
private:
    std::string name_;
    std::string password_;
};

데이터베이스와 상호작용하는 UserRepository 클래스

class UserRepository {
public:
    std::shared_ptr<User> GetUserByName(const std::string& name) {
        // 데이터베이스에 연결하여 쿼리 실행
        // ...
        // 결과를 User 객체로 변환하여 반환
        return std::make_shared<User>(name, "password");
    }
};

UserRepository를 사용하여 로그인 인증을 수행하는 LoginService 클래스

class LoginService {
public:
    bool Authenticate(const std::string& name, const std::string& password) {
        UserRepository repository;
        std::shared_ptr<User> user = repository.GetUserByName(name);
        if (!user) {
            return false;
        }
        return user->GetPassword() == password;
    }
};

이제 LoginService의 Authenticate 함수를 테스트하려면 UserRepository 클래스의 GetUserByName 함수를 호출해야 함

그러나 이 함수는 데이터베이스에 직접 연결하기 때문에 테스트하는 데 시간이 많이 소요됨

따라서 mocking을 사용하여 UserRepository 클래스의 GetUserByName 함수를 대체할 수 있음

이를 위해 UserRepository 클래스를 인터페이스로 추상화하고, 이 인터페이스를 상속하는 MockUserRepository 클래스를 작성

class IUserRepository {
public:
    virtual std::shared_ptr<User> GetUserByName(const std::string& name) = 0;
};

class MockUserRepository : public IUserRepository {
public:
    MOCK_METHOD1(GetUserByName, std::shared_ptr<User>(const std::string& name));
};

여기서 MOCK_METHOD1 매크로는 IUserRepository 클래스의 GetUserByName 함수를 대체하기 위한 mocking 함수를 생성

이제 LoginService 클래스의 Authenticate 함수를 테스트하려면 MockUserRepository 클래스의 GetUserByName 함수를 호출

TEST(LoginServiceTest, TestAuthenticate) {
    // Mocking을 사용하여 UserRepository 대체
    MockUserRepository repository;
    LoginService service;

    // mocking 함수 설정
    EXPECT_CALL(repository, GetUserByName("Alice"))

Mocking with multiple dependencies (다수의 의존성을 가진 클래스에 대해 mocking을 수행하는 예제)

아래 코드에서는 ClassA와 ClassB 두 개의 클래스가 ClassC에서 의존성으로 사용되며,

ClassC의 테스트를 위해 ClassA와 ClassB를 mocking

class ClassA {
public:
  virtual void funcA() = 0;
};

class ClassB {
public:
  virtual void funcB() = 0;
};

class ClassC {
public:
  ClassC(std::shared_ptr<ClassA> a, std::shared_ptr<ClassB> b) 
    : a_(a), b_(b) {}

  void funcC() {
    a_->funcA();
    b_->funcB();
  }

private:
  std::shared_ptr<ClassA> a_;
  std::shared_ptr<ClassB> b_;
};

TEST(ClassCTest, TestFuncC) {
  // Mock ClassA and ClassB
  auto mockA = std::make_shared<MockClassA>();
  auto mockB = std::make_shared<MockClassB>();

  // Set expectations
  EXPECT_CALL(*mockA, funcA());
  EXPECT_CALL(*mockB, funcB());

  // Inject mocks into ClassC
  ClassC c(mockA, mockB);

  // Test ClassC's funcC
  c.funcC();
}

2. Mocking with non-virtual interface (가상 함수가 아닌 인터페이스를 사용하는 클래스에 대해 mocking을 수행하는 예제)

아래 코드에서는 ClassD가 ClassE를 의존성으로 사용하며, ClassD를 mocking

ClassD는 인터페이스인 ID를 구현하며, ClassE는 ID를 통해 ClassD와 상호작용함

class ID {
public:
  virtual void funcD() = 0;
};

class ClassD : public ID {
public:
  void funcD() override {
    funcE();
  }

  virtual void funcE() {
    // implementation
  }
};

class ClassE {
public:
  ClassE(ID& d) : d_(d) {}

  void funcE() {
    d_.funcD();
  }

private:
  ID& d_;
};

class MockClassD : public ID {
public:
  MOCK_METHOD(void, funcD, (), (override));
};

TEST(ClassETest, TestFuncE) {
  // Mock ClassD
  MockClassD mockD;

  // Set expectations
  EXPECT_CALL(mockD, funcD());

  // Create ClassE with mockD
  ClassE e(mockD);

  // Test ClassE's funcE
  e.funcE();
}

3. Partial Mocking (Partial Mocking을 사용하여 클래스의 일부 함수만 mocking 하는 예제)

아래 코드에서는 ClassF가 funcF와 funcG 함수를 가지며, funcF를 mocking

funcG 함수는 실제로 호출되며, ClassF의 인스턴스는 Partial Mocking이 적용

class ClassF {
public:
  virtual void funcF() {
    // implementation
  }

  void funcG() {
    // implementation
  }
};

TEST(ClassFTest, TestFuncF) {

+ QNX 에서 WillOnce 사용 불가.

이 경우에는 대신 OnCall 함수를 사용하여 함수 호출 시점에서 특정 값을 반환하도록 설정

class MyClass {
public:
    virtual int GetValue() const { return 0; }
};

class MyMock : public MyClass {
public:
    MOCK_CONST_METHOD0(GetValue, int());
};

MyMock 클래스에서 GetValue() 함수를 mock으로 설정하고,

WillOnce 함수를 사용하여 값을 반환하는 것 대신,

OnCall 함수를 사용하여 특정 값을 반환하도록 설정할 수 있습니다.

즉 다음과 같은 방법으로 설정할 수 있음

MyMock mock;
EXPECT_CALL(mock, GetValue())
    .WillOnce(Invoke([&]() {
        // OnCall 대신에 직접 처리하면 됩니다.
        return 42;
    }));

이제 MyMock의 GetValue() 함수가 호출되면, 42를 반환하도록 설정되어 있음

이렇게 하면 WillOnce 함수를 사용할 수 없는 환경에서도 유용한 방법으로 mocking을 구현할 수 있음

예제2

#include <iostream>
#include <memory>

class IDataReader {
public:
    virtual ~IDataReader() = default;
    virtual int ReadData(char* buffer, int size) = 0;
};

class MockDataReader : public IDataReader {
public:
    MOCK_METHOD(int, ReadData, (char* buffer, int size), (override));
};

class DataProcessor {
public:
    explicit DataProcessor(std::shared_ptr<IDataReader> reader) : reader_(std::move(reader)) {}

    bool ProcessData() {
        char buffer[1024];
        int bytes_read = reader_->ReadData(buffer, sizeof(buffer));

        if (bytes_read < 0) {
            std::cerr << "Error reading data" << std::endl;
            return false;
        }

        // process the data...

        return true;
    }

private:
    std::shared_ptr<IDataReader> reader_;
};

class MockDataReaderWrapper : public IDataReader {
public:
    MockDataReaderWrapper(MockDataReader& mock_reader) : mock_reader_(mock_reader) {}

    int ReadData(char* buffer, int size) override {
        return mock_reader_.ReadData(buffer, size);
    }

private:
    MockDataReader& mock_reader_;
};

TEST(DataProcessorTest, ProcessDataTest) {
    MockDataReader mock_reader;
    MockDataReaderWrapper mock_reader_wrapper(mock_reader);
    DataProcessor processor(std::make_shared<MockDataReaderWrapper>(mock_reader_wrapper));

    EXPECT_CALL(mock_reader, ReadData(_, _)).WillOnce(Return(10));

    ASSERT_TRUE(processor.ProcessData());
}

이 예제에서는 IDataReader라는 인터페이스를 정의하고, 이를 구현하는 MockDataReader 클래스를 만들었음

그리고 DataProcessor 클래스는 IDataReader 객체를 인자로 받아 데이터를 처리함

위 예제에서는 WillOnce 함수 대신 MockDataReaderWrapper 클래스를 만들어 사용

MockDataReaderWrapper 클래스는 IDataReader 인터페이스를 구현하면서, 내부적으로 MockDataReader 객체를 참조 DataProcessor 클래스에서는 std::shared_ptr<IDataReader> 타입으로 MockDataReaderWrapper 객체를 받아 처리

마지막으로 EXPECT_CALL 매크로를 사용하여 MockDataReader 클래스의 ReadData 함수가 호출될 때 반환 값을 지정

이 때 ReadData 함수는 MockDataReaderWrapper 클래스를 통해 호출됨

이 예제에서는 MockDataReaderWrapper 클래스를 사용하여 QNX 환경에서 WillOnce 함수를 대체할 수 있음

[C++] virtual table 역할 및 필요성

꼬북칩조아 — Fri, 24 Mar 2023 23:18:03 +0900

C++에서 가상 함수(Virtual function)은 다형성을 구현하는데 매우 중요한 역할을 함

가상 함수는 일반적인 멤버 함수와 달리, 함수 호출시 객체의 실제 타입을 기반으로 호출할 함수를 동적으로 바인딩

이를 통해 런타임 다형성을 지원하며, 객체의 동작을 유연하게 변경할 수 있음

가상 함수를 사용하면 다형성을 지원하는 클래스의 인스턴스들이 메모리 상에서 어떻게 구성되는지를 관리하는 Virtual table이 생성됨

가상 테이블은 가상 함수의 포인터를 저장하고, 객체의 실제 타입에 맞는 가상 함수를 호출

이렇게 가상 함수와 가상 테이블을 사용하여 다형성을 구현함으로써, OOP 특징인 추상화, 캡슐화, 상속, 다형성 등 특징을 활용할 수 있음

가상 테이블은 클래스의 정의가 컴파일 될 때 만들어지며, 각 클래스당 하나씩 존재

가상 테이블은 각 객체에게 독립적으로 할당되며, 객체의 가상 함수 호출은 해당 객체의 가상 함수 테이블을 통해 이루어짐

객체가 생성될 때, 가상 함수 포인터 테이블이 생성되며, 이 테이블에는 해당 객체의 가상 함수들에 대한 포인터들이 저장됨

상속 관계에서 파생 클래스의 가상 함수 테이블은 기본 클래스의 가상 함수 테이블을 상속받음

만약 파생 클래스에서 기본 클래스의 가상 함수를 재정의(오버라이딩)하면, 해당 함수에 대한 포인터가 파생 클래스의 가상 함수 테이블에 저장됨

이렇게 하위 클래스에서 재정의된 가상 함수는 상위 클래스의 가상 함수 대신 호출되며, 다형성을 구현할 수 있음

따라서, 가상 테이블은 클래스의 정의 시점에 만들어지며, 객체의 가상 함수 호출은 해당 객체의 가상 함수 포인터 테이블을 통해 이루어짐 상속 관계에서 파생 클래스는 기본 클래스의 가상 함수 테이블을 상속받으며,

재정의한 함수에 대한 포인터가 파생 클래스의 가상 함수 테이블에 저장됨

스마트 포인터와의 관계

가상 테이블(virtual table)에는 스마트 포인터 정보가 저장되지 않음

(스마트 포인터는 C++에서 메모리 관리를 자동화하기 위한 도구로 사용되며, 동적으로 할당된 객체를 다루는 포인터)

스마트 포인터는 객체의 수명을 관리하며, 가상 테이블과는 관련은 없음

가상 테이블은 객체의 가상 함수 호출을 위한 메커니즘을 제공하는 데 사용되며, 스마트 포인터는 객체의 수명을 관리하는 데 사용

따라서, 가상 테이블에는 가상 함수 포인터만 저장되며, 스마트 포인터 정보는 저장되지 않음

스마트 포인터가 사용되는 경우, 가상 함수가 호출되는 시점에 객체가 여전히 유효한지 확인하기 위해 스마트 포인터가 사용될 수 있음

이 경우, 스마트 포인터가 가상 테이블과는 별개로 사용됨

[C++] stream 클래스 상속 관계

꼬북칩조아 — Fri, 24 Mar 2023 23:04:22 +0900

stream 클래스 상속 관계

C++의 입출력 라이브러리는 스트림(Stream) 클래스를 기반으로 구현되어 있는데,

이 스트림 클래스는 데이터를 읽고 쓰는 데 필요한 기본적인 인터페이스를 제공하며,

이를 상속하는 다양한 클래스를 통해 입출력 기능을 확장할 수 있음

가장 기본이 되는 스트림 클래스는 istream, ostream, iostream 가 있음

istream은 입력 스트림을, ostream은 출력 스트림을, iostream은 입력 및 출력을 모두 지원하는 스트림 클래스

이들 클래스는 각각 ifstream, ofstream, fstream 클래스에서 상속받아 파일 입출력을 지원.

istringstream, ostringstream, stringstream 클래스에서 상속받아 문자열을 입출력하는 기능을 지원.

스트림 클래스 상속 구조를 이용하면, 입출력 기능을 다양한 방법으로 확장 가능

예를 들어, istream 클래스에서 상속받아 구현한 새로운 클래스를 통해, 입력 데이터를 다른 형식으로 파싱하거나, 입력 스트림에서 특정 패턴을 찾아 처리할 수 있습니다. 마찬가지로, ostream 클래스에서 상속받아 구현한 새로운 클래스를 통해, 출력 데이터를 다른 형식으로 변환하거나, 출력 스트림에서 특정 패턴을 찾아 처리할 수 있음

1) istream 클래스에서 상속받아 구현한 새로운 클래스를 통해, 입력 데이터를 다른 형식으로 파싱하는 예제

#include <iostream>
#include <sstream>

class MyInputStream : public std::istream {
public:
    MyInputStream(std::streambuf* buf) : std::istream(buf) {}

    int readInt() {
        int n;
        *this >> n; // 입력 스트림에서 정수를 읽어옴
        std::string s = std::to_string(n); // 정수를 문자열로 변환
        std::reverse(s.begin(), s.end()); // 문자열을 뒤집음
        return std::stoi(s); // 뒤집은 문자열을 다시 정수로 변환하여 반환
    }
};

int main() {
    std::istringstream iss("1234");
    MyInputStream mis(iss.rdbuf()); // MyInputStream 객체 생성

    int n = mis.readInt(); // MyInputStream 클래스에서 추가한 readInt() 함수 사용
    std::cout << "Reversed integer: " << n << std::endl; // 출력 결과: Reversed integer: 4321

    return 0;
}

MyInputStream : istream 클래스에서 상속받아 정수를 읽어오는 readInt() 함수를 추가한 새로운 클래스

readInt 함수: 입력 스트림에서 정수를 읽어와 문자열로 변환한 후, 문자열을 뒤집어 다시 정수로 변환하여 반환

main() 함수에서는 istringstream 객체를 생성하고, 이를 MyInputStream 클래스의 객체로 래핑하여 입력 데이터를 처리.

이 때 MyInputStream 클래스에서 추가한 readInt() 함수를 사용하여 입력 데이터를 다른 형식으로 파싱

#include <iostream>
#include <sstream>

class MyInputStream : public std::istream {
public:
    MyInputStream(std::streambuf* buf) : std::istream(buf) {}

    MyInputStream& operator>>(int& n) {
        std::string s;
        *this >> s; // 입력 스트림에서 문자열을 읽어옴
        if (s[0] == '-') { // 입력값이 음수인 경우
            std::reverse(s.begin() + 1, s.end()); // 음수 부호를 제외한 문자열을 뒤집음
            n = -std::stoi(s); // 뒤집은 문자열을 음수로 변환하여 반환
        }
        else { // 입력값이 양수인 경우
            std::reverse(s.begin(), s.end()); // 문자열을 뒤집음
            n = std::stoi(s); // 뒤집은 문자열을 정수로 변환하여 반환
        }
        return *this;
    }
};

int main() {
    std::istringstream iss("-1234");
    MyInputStream mis(iss.rdbuf()); // MyInputStream 객체 생성

    int n;
    mis >> n; // MyInputStream 클래스에서 추가한 >> 연산자 사용
    std::cout << "Reversed integer: " << n << std::endl; // 출력 결과: Reversed integer: -4321

    return 0;
}

MyInputStream : istream 클래스에서 상속받아 >> 연산자 오버로딩을 추가한 새로운 클래스

operator>> 함수 : 입력 스트림에서 문자열을 읽어와 음수인 경우 음수 부호를 제외한 문자열을 뒤집고 음수로 변환하거나, 양수인 경우 문자열을 뒤집어 정수로 변환하여 반환

main() 함수에서는 istringstream 객체를 생성하고, 이를 MyInputStream 클래스의 객체로 래핑하여 입력 데이터를 처리

이 때 MyInputStream 클래스에서 추가한 >> 연산자를 사용하여 입력 데이터를 다른 형식으로 파싱

2) 입력 스트림에서 특정 패턴을 찾아 처리

입력 스트림에서 특정 패턴을 찾아 처리하는 예제 코드

이 예제에서는 입력 스트림에서 "[[name]] : [age]" 형태의 패턴을 찾아, name과 age를 출력

#include <iostream>
#include <string>
#include <regex>

int main() {
    std::string input = "John : 30\n[[Sarah]] : 25\n[[David]] : 40\nMary : 35";

    std::regex pattern(R"(\[\[(\w+)\]\] : (\d+))");
    std::smatch match;

    std::string::const_iterator search_start(input.cbegin());
    while (std::regex_search(search_start, input.cend(), match, pattern)) {
        std::cout << "Name: " << match[1].str() << ", Age: " << match[2].str() << std::endl;
        search_start = match.suffix().first; // 처리한 패턴 뒷부분으로 검색 시작 위치를 갱신함
    }

    return 0;
}

std::regex 클래스를 사용하여 "[[name]] : [age]" 형태의 패턴을 정규 표현식으로 표현

이후 std::regex_search 함수를 사용하여 입력 문자열에서 패턴을 찾아 match 객체에 저장

while 루프에서는 검색 시작 위치를 갱신하면서 계속해서 패턴을 찾아 처리

std::smatch 객체의 [] 연산자를 사용하여 패턴에서 추출한 name과 age 값을 출력

입력 문자열에서 "[[name]] : [age]" 형태의 패턴이 여러 번 나오기 때문에, while 루프를 사용하여 모든 패턴을 찾아 처리

이때 search_start 변수를 사용하여 처리한 패턴 뒷부분으로 검색 시작 위치를 갱신

입력 스트림에서 특정 패턴을 찾아 처리하는 좀 더 복잡한 예제 코드

이 예제에서는 입력 스트림에서 "Name: [name]\nAge: [age]\n" 형태의 패턴을 찾아, name과 age를 출력

이때 입력 스트림으로부터 데이터를 읽는 과정에서 에러가 발생하는 경우, 해당 에러 메시지를 출력하고 다음 데이터를 처리

#include <iostream>
#include <sstream>
#include <string>
#include <regex>

int main() {
    std::string input = "Name: John\nAge: 30\nName: Sarah\nAge: 25\nName: David\nAge: 40\nName: Mary\nAge: invalid\nName: Tom\n";

    std::istringstream stream(input);
    std::regex pattern(R"(Name: (\w+)\nAge: (\d+))");
    std::smatch match;

    std::string name, age;
    std::string line;
    while (std::getline(stream, line)) {
        if (std::regex_match(line, match, pattern)) {
            name = match[1].str();
            age = match[2].str();
            std::cout << "Name: " << name << ", Age: " << age << std::endl;
        } else if (line.find("Name: ") == 0) {
            std::cerr << "Invalid input: " << line << std::endl;
        }
    }

    return 0;
}

입력 문자열에서 "Name: [name]\nAge: [age]\n" 형태의 패턴을 std::regex 클래스를 사용하여 정규 표현식으로 표현

이후 std::getline 함수를 사용하여 입력 스트림에서 데이터를 한 줄씩 읽어와 처리

while 루프에서는 std::getline 함수를 사용하여 입력 스트림에서 한 줄씩 데이터를 읽어옴

이때 std::regex_match 함수를 사용하여 읽어온 데이터가 패턴과 일치하는지 확인

일치하는 경우에는 match 객체에 저장된 name과 age 값을 출력

패턴과 일치하지 않는 데이터가 입력 스트림에서 읽혀올 경우에는 에러 메시지를 출력

이때, 입력 스트림으로부터 다음 데이터를 처리하기 위해 std::cerr 객체를 사용하여 에러 메시지를 출력

위 예제 코드에서는 입력 스트림으로부터 데이터를 읽는 과정에서 에러가 발생하는 경우, 해당 에러 메시지를 출력하고 다음 데이터를 처리 이를 통해 입력 데이터의 오류를 검출하고 처리할 수 있음

ostream 클래스에서 상속받아 구현한 새로운 클래스를 통해, 출력 데이터를 다른 형식으로 변환하는 예제

ostream 클래스에서 상속받아 구현한 새로운 클래스를 통해, 출력 데이터를 다른 형식으로 변환하는 예제입니다. 이 예제는 std::ostream을 상속받아 std::ostream으로 출력되는 데이터를 16진수로 변환하여 출력하는 HexOstream 클래스를 구현한 예제

#include <iostream>
#include <iomanip>

class HexOstream : public std::ostream
{
public:
    HexOstream(std::ostream& os) : std::ostream(os.rdbuf()) {}

    HexOstream& operator<<(int value)
    {
        std::ostream& os = *this;
        os << std::hex << std::setw(2) << std::setfill('0') << value;
        return *this;
    }
};

int main()
{
    HexOstream hex_os(std::cout);

    int value = 123;
    hex_os << "value in hex: ";
    hex_os << value;

    return 0;
}

위 예제에서 HexOstream 클래스는 std::ostream 클래스를 상속받아 구현되

HexOstream 클래스는 operator<< 연산자를 오버로딩하여 16진수로 변환하여 출력

HexOstream 클래스의 operator<< 연산자는 인자로 받은 int 타입의 value 변수를 16진수로 변환하여 출력

이를 위해 std::hex 조작자를 이용하여 16진수 출력 모드로 변경하고, std::setw와 std::setfill 조작자를 이용하여 출력 폭을 맞추고 빈 자리는 0으로 채움

main() 함수에서는 HexOstream 클래스를 생성하여 std::cout 스트림을 인자로 전달

그리고 int 타입의 value 변수를 생성하고, HexOstream 클래스를 이용하여 value 변수를 출력

출력 결과

value in hex: 7b

std::ostream을 상속받아 사용자 정의 출력 스트림 클래스 MyOstream을 구현한 예제

MyOstream 클래스는 기존 출력 스트림에 대해 스트림 버퍼를 이용해 대문자로 변환하여 출력하는 기능을 추가

#include <iostream>
#include <streambuf>
#include <locale>
#include <algorithm>

class MyOstream : public std::ostream {
public:
    MyOstream(std::ostream& stream)
        : std::ostream(stream.rdbuf()), _streambuf(stream.rdbuf())
    {}

    MyOstream& operator<< (const char* str) {
        std::transform(str, str + strlen(str), str, [](char c) {
            return std::toupper(c, std::locale());
        });

        _streambuf->sputn(str, strlen(str));
        return *this;
    }

private:
    std::streambuf* _streambuf;
};

int main() {
    MyOstream myout(std::cout);
    myout << "Hello, world!" << std::endl;
    return 0;
}

MyOstream 클래스는 std::ostream을 상속받아 구현되

생성자에서 std::ostream으로부터 스트림 버퍼를 가져오며, operator<< 연산자를 오버로딩하여 출력할 문자열을 대문자로 변환하여 출력

operator<< 연산자에서는 입력으로 받은 문자열을 std::transform 알고리즘을 이용하여 대문자로 변환

그리고 스트림 버퍼에 변환된 문자열을 써넣어 출력

main() 함수에서는 MyOstream 클래스를 이용하여 std::cout으로 출력하는 myout 객체를 생성하고, myout 객체를 이용하여 "Hello, world!" 문자열을 출력합니다.

출력 결과

HELLO, WORLD!

이와 같이 std::ostream 클래스를 상속받아 사용자 정의 출력 스트림 클래스를 구현하면,

기존의 출력 스트림에 기능을 추가하거나 사용자 정의 출력 형식을 지원할 수 있음

ostream 클래스에서 상속받아 구현한 새로운 클래스를 통해, 출력 스트림에서 특정 패턴을 찾아 처리하는 예제

std::ostream을 상속받아 사용자 정의 출력 스트림 클래스 MyOstream을 구현한 예제

MyOstream 클래스는 기존 출력 스트림에 대해 스트림 버퍼를 이용해 특정 패턴을 찾아서 대체 문자열로 변환하는 기능을 추가

#include <iostream>
#include <streambuf>
#include <cstring>

class MyOstream : public std::ostream {
public:
    MyOstream(std::ostream& stream, const std::string& pattern, const std::string& replace)
        : std::ostream(stream.rdbuf()), _streambuf(stream.rdbuf()), _pattern(pattern), _replace(replace)
    {}

    MyOstream& operator<< (const char* str) {
        std::string s(str);
        size_t pos = s.find(_pattern);
        while (pos != std::string::npos) {
            s.replace(pos, _pattern.length(), _replace);
            pos = s.find(_pattern, pos + _replace.length());
        }

        _streambuf->sputn(s.c_str(), s.length());
        return *this;
    }

private:
    std::streambuf* _streambuf;
    std::string _pattern;
    std::string _replace;
};

int main() {
    MyOstream myout(std::cout, "world", "WORLD");
    myout << "Hello, world!" << std::endl;
    return 0;
}

MyOstream 클래스는 std::ostream을 상속받아 구현되었습니다. 생성자에서는 스트림 버퍼와 대체할 패턴과 문자열을 지정 operator<< 연산자를 오버로딩하여 출력할 문자열에서 패턴을 찾아서 대체 문자열로 변환

operator<< 연산자에서는 입력으로 받은 문자열에서 std::string::find 함수를 이용하여 패턴을 찾음

패턴이 있으면 std::string::replace 함수를 이용하여 대체 문자열로 변환

이후 다시 std::string::find 함수를 호출하여 패턴을 찾습니다. 이 과정을 반복하여 패턴이 더 이상 없을 때까지 대체

마지막으로 변환된 문자열을 스트림 버퍼에 써넣어 출력

main() 함수에서는 MyOstream 클래스를 이용하여 std::cout으로 출력하는 myout 객체를 생성하고,

myout 객체를 이용하여 "Hello, world!" 문자열을 출력

출력 결과

HELLO, WORLD!

[16] if 가정법

꼬북칩조아 — Fri, 24 Mar 2023 07:29:53 +0900

Part1. 일반 사실을 바탕으로 하는 일반 조건절

걔가 아무말도 안하면, 걔가 화났다는 거야

☞ If he doesn't say anything, that means he is upset.

냄새가 안좋으면, 아마 먹기에 안전하지 않다는거야

☞ If it smells bad, it's probably not safe to eat

거기 사람이 너무 많으면, 다른데 가는게 나을거 같아

☞ If there are too many people, it's better to go somewhere else

지하철 타면, 더 빨라

☞ If you take the subway, it's faster

5시 전에 나가면, 차 별로 안막힐거야

☞ If you leave before 5 o'clock, there isn't much traffic

Part2. 현재 사실을 뒤집어서 조건절로

< if + 과거 시제 , could / would be able to >

내 학교에서 먼 곳에 살아, 그래서 아침에 학교가는데 시간이 오래 걸려

학교에 좀 더 가까이 살았으면, 시간을 좀 더 절약할 수 있을 텐데

I live far from school, so it takes a lot of time to go to school in the morning

☞ If I lived closer to school, I could(would be able to) save more time.

live 안됨 can 안됨

나 일주일에 6 번 일하러가. 그래서 주말에 계획 세우는게 어려워

일주일에 딱 5일만 간다면, 주말에 더 많은 것들을 할 수 있을텐데

I go to work 6 times a week. So it's hard to make plans on weekends

☞ If I went to work just 5 days a week, I would be able to(could) do more things on weekends.

난 외장하드를 하나 갖고 있어, 그래서 어딜가든 음악이나 영화 갖고 다닐 수 있어

이게 없다면, 그러진 못할 거야

I have an external hard drive, so i can carry my music and movies wherever I go

☞ If I didn't have one, I woudn't be able to (couldn't) do that

*one : 일반적인 외장하드 (꼭 내 드라이브가 아니더라도)

나는 살이 쉽게 쪄, 그래서 먹는걸 조심해야돼

내가 쉽게 찌지 않는다면, 좀더 자유롭게 음식을 즐길텐데

I gain weight quite easily, so I have to be careful about what i eat.

☞ But if I didn't gain weight so easily, I would be able to enjoy food more freely

저는 경험이 많지 않아서요 , 그래서 시간이 오래 걸려요

경험이 많았으면, 그렇게 오래걸리진 않았을거에요

I don't have any experience, so it takes a lot of time

☞ If I had a lot of experience, it wouldn't take so long

Part3. 조건절 미래 (조건절은 현재형 시제)

1) 어떤 조건 하에 나의 의지/계획/인과관계 (be going to)

이번주에 비오면, 집에 있을려고

☞ If it rains this weekend, I'm going to stay home.

그녀가 물어보면, 나 그냥 아무것도 모르는척 할거야

☞ If she asks, I'm just gong to pretend I don't know anything

오늘 일찍 퇴근하면, 친구들 몇명 만나서 술한잔 하게

☞ If I get off work early today, I'm going to meet up with some friends for some drinks.

이런 일이 또 발생하면 걔들은 모든걸 잃을걸

☞ If this happens again, they're going to lose everything

2) 어떤 조건 하에 ~ 을 할 수도 있다/할지도 모른다/ 해도 된다/ 하면 된다 (can / might/ don't have to )

이게 마음에 안들면, 환불 해도돼 (환불 : refund 보다는 return / send it back 을 좀 더 많이 씀 )

☞ If you don't like it, you can return it / send it back

진짜 열심히 공부하면, 시험 통과할 수도 있어

☞ If you study really hard, you might pass the test

늦으면 택시 타도돼

☞ If you're late, you can just take a taxi

그녀한테 사실대로 얘기하면, 이해해줄수도 있어

☞ If you tell her the truth, she might understand

배 안고프면 안먹어도돼

☞ You don't have to eat if you're not hungry

3) 조동사+조동사 or 시제 + 조동사 (might have to / might be able to or will be able to / be going to be able to )

"~ 해야 될 수도 있어" / "~ 할 수도 있어" or "~해야 할거야" (미래 + 가능성)

내가 돈을 충분히 못 모으면 빌려야 될 수도 있어

☞ If I can't save enough money, I might have to borrow some. (아주 많이 씀 ; ~해야 될수도있다)

오늘 회의에서 마이클이 발표 하기로 돼있어. 근데 걔가 늦으면 너가 해야될 수도 있어

☞ Michael is supposed to give a presentation in the meeting today. But if he's late, you might have to do it

걔들이 우릴 도와주지 않으면, 우리는 이걸 제시간에 끝낼 수 없을 거야

☞ If they don't help us, we won't be able to finish this on time.

우리 지금 가면 막차 탈 수도 있어

☞ If we leave(go) now, we might be able to catch the last train/bus

날씨가 진짜 좋으면, 좋은 사진들 좀 찍을 수 있을 거야

☞ If the weather is really clear(nice), we're going to be able to takes some nice picture

Part4. 과거에 이미 일어났던일을 반대로 가정

1) ~ 을 했을거야 / 이랬을거야 / 저랬을거야 (would have pp)

저 어제 늦게 잤어요. 그래서 오늘 아침에 일어나는게 힘들었어요

어제 좀 더 일찍 잤다면, 오늘 일어나는게 그렇게 힘들지 않았을거야

☞ I went to be late yesterday and/ so it was hard to get up this morning

If I had gone to bed earlier last night / yesterday, It wouldn't have been so hard to get up this morning

내가 준비가 안됐었어, 그래서 인터뷰 잘 못했어

좀 더 준비가 돼있었으면, 좀 더 잘 할 수 있었을 텐데

☞ I wasn't prepared, so I didn't do well on the interview

If I had been more prepared, I would've done better (on the interview)

아침을 안먹었어서, 시험보는 동안 너무 배고팠었어

내가 아침 먹었었더라면, 시험 보는 동안 그렇게 배고프진 않았을거야

☞ I didn't eat breakfast, so I was very hungry during the test

If I had eaten breakfast, I wouldn't have been so hungry during the test and I would've concentrated batter'

걔 상황을 몰랐어, 그래서 못도와 줬어

걔 상황을 알았었다면 도와 줬을 텐데

☞ I didn't know about his situation, so I couldn't help him

If I had known about his situation, I would've helped him

2) ~을 할 수도 있었을 거야 / ~ 했었을 지도 몰라 (might have pp)

걔가 나한테 물어봤었다면, 도와줬을 지도 몰라

☞ If he had asked me, I might've helped him

그녀가 좀 더 열심히 연습을 했었으면, 그 실수를 안했을 지도 몰라

☞ If she had practiced harder, she might not've made that mistake

내가 좀 더 알아봤더라면, 다른 결정을 했었을지도 몰라

☞ If I had looked into it (a little more), I might've made a different decision/ chosen a different one

*look into something : ~을/에 대해서 알아보다

그가 그녀한테 말 안했었으면 걔는 그게 얼마나 중요한건지 몰랐을지도 몰라

☞ If he hadn't told her, she might not've realized how important it was

3) ~을 할 수도 있었을 거야 / ~ 할 수 있었을 텐데 (could have pp)

공부를 좀 열심히 했었더라면,더 좋은 학교에 갈 수 있었을텐데

☞ If I had studied harder, I could've gone to a better school

(would have been able to)

*could've : 더 좋았었을 결과에 대해 말할 때 (아쉬움이 있는 뉘앙스)

*might've : 추측

나한테 물어봤었으면, 내가 도와줄수 있었는데

☞ If you had asked me, I could've helped you

니가 도와주지 않았다면, 제시간에 못끝냈을 거야

☞ If you had not helped me, I couldn't have finished this on time

우리가 조금이라도 늦게 떠났다면, 여기에 이시간에 도착못햇을거야

☞ If we had left a little later, we couldn't have arrived here at this time

4) ~해야 했을거야 / 해야 됐었을거야 / (부정형) ~하지 않아도 됐을거야 (would've had to, would've needed to)

내가 돈을 충분히 모으지 못했었으면, 거기에 1년 더 있었어야 했을거야

☞ If I hadn't saved enough money, I would've had to be(stay) there for another year

그녀가 시험을 합격 못했었으면, 1년더 (시험을) 준비해야 했을 거야

☞ If she hadn't passed the exam, she would've had to prepare another year for the test // preapre for the test for another year

너가 좀 더 일찍 얘기해줬으면, 내가 이렇게 오래 안기다려도 됐었잖아

☞ If you had told me a little earlier, I wouldn't have had to wait this long

내가 그 실수를 하지 않았으면, 우리가 이걸 다시 할 필요가 없었을거야

☞ If I hadn't made that mistake, we wouldn't have had to do this again

Practice

1. If I knew I got to regret not to speak English well, I would've studied harder and harder

☞ 영어에서는 '후회할줄 알았으면' 이라는 표현을 쓰지 않음

☞ If I knew(had known) I would need to use English, I would've studied harder.

2. If I knew your phone number, I would call you

☞ 과거로 바꾸면,

☞ If I knew(had known) your phone number, I would've called you

3. If I knew LA earlier, I wouldn't have difficulty in learning English.

☞ knew + something 인 경우, 전치사 about 필요 (사람인 경우에는 필요없음)

☞ If I knew(had known) about LA earlier, I wouldn't have had such a difficult time learning english.

4. If I had known it had car accident, I would have fastened seat belt.

☞ If I had known I would be in a car accident, I would've fastened seat belt

☞ If I had known there would be a car accident, I would've fastened my seat belt

5. If I had known about that accident, I wouldn't have gone through a rough period. I should've known it.

☞ 이미 일어난 일에 대한 시간에 대해 표현 "such" a rough period

☞ If I had known that happened (about that), I wouldn't have gone through such a rough period.

I should've know about it

6. If I had had money enough, I would have bought the house

☞ had + had 는 가능하면 피하는 것이 좋음(?)

☞ If I had enough money, I would have bought the house

7. If I knew about the Live Academy earlier, I wouldn't have spent my time exploring other Youtube channels

☞ 이미 일어난 일에 대한 시간 "so much time"

☞ If I knew about the Live Academy earlier, I wouldn't have spent so much time exploring other Youtube channels

8. If I had known she'd been already married, I wouldn't have tried to asking her phone number

☞ 이미 결혼한 상태 (was already married), 물어보는 것은 선택 (굳이 노력 언급 X)

☞ 전화번호를 달라고 하다: asked 'for' her phone number

☞ If I had known she was already married, I wouldn't have asked for her phone number

9. If I knew that was wrong, I wouldn't have done that

10. If I had known the fact that she already dated another guy, I wouldn't have loved her

☞ 만나고 있는 중 이므로 was dating, love 보다는 관심을 갖다 interested in

☞ If I had known she was (already) dating another guy, I wouldn't have taken interest in her

11. If I had known what I know when I was in college, I would have live a better life.

☞ Back (when I was) in collge, if I had known what I know now, I would have lived a better life. 13'

그거 항상 그랬어 / 이게 원래 이런거야? / ~을 꼭 하다 (make sure) 영어로 + later, in 활용

꼬북칩조아 — Thu, 23 Mar 2023 07:02:01 +0900

그거 항상 그랬어 < It's always been like that >
이게 원래 이런거야? < It's supposed to be like this ? >
그런지 좀 됐다고 < It's been like that for a while (now) >
그 이후로 그래 < It's been like that ever since >

A: 이거 왜이래?
B: 왜?
A: 힌지 말이야. 왜 이러지?
B: 아 그거?, 그거 항상 그랬어
A: 이게 원래 이런거라고?
B: 아니 내말은 그런지 (이제) 좀 됐다는 거야
A: 지난번에 봤을 땐 안이랬는데
B: 맞아 그랬었어. Kyle 이 실수로 깔고 앉았던거 기억나?
A: 아니
B: 암튼 그랬었는데, 그게 일년도 넘은 일이야. 그 이후로 그랬어

A: What's wrong with this ?
B: Why?
A: The hinge. Why is it like this ?
B: Oh that? Yeah, It's always been like that
A: You mean it's supposed to be like this?
B: No I mean it's been like that for a while (now)
A: It wasn't like this the last time I saw it
B: Yeah, it was. Remember when Kyle accidentally sat on it ?
A: No
B: Well, he did and that was like more than a year ago. It's been like that ever since

*now가 현재 완료형과 함께 '이제' 정도의 의미로 쓰이는 경우

It's been several months now : 이제 몇개월 됐네

* ever since 와 after that

It's been like that ever since : 그 이후로 쭉 그 상태

It became like that after that : 그러고 나서 그렇게 됐어

make sure

make sure ~ : ~을 꼭 (어떻게) 하다 (무엇을 "확실하게/분명하게 만들다" 라는 의미가 아님!)

꼭 ...(어떻게) 해주세요 (부탁)
Please make sure to ... :

집에 오면 꼭 손 씻으세요
Please make sure to wash your hands (when you get home/ before you eat /after you use the bathroom)

나는 꼭 (어떻게) 한다
I make sure to do something

나는 집에오면 손을 꼭 씻는다
I make sure to wash my hands when I get home.

나는 나가기전에 꼭 (항상) 폰을 풀충전한다
I always make sure that my phone is fully charged before I go out.
(I always make sure to fully charge my phone before I go out)

마스크 꼭 챙기세요
Make sure (that) you have your mask

난 나가기 전에 마스크를 꼭 챙겨요
I (always) make sure (that) I have my mask before I go out

나는 여분 마스크를 꼭 하나 가지고 다녀요. 혹시 하나 잃어버릴까봐..
I always make sure that I carry on extra mask just in case I lose one

두시간 이상 나가 있을 예정일 때는 강아지 물그릇을 꼭 가득 채워놔요
When I'm going out for more than a couple of hours, I always make sure to fill up my dog's water bowl.

이 표현에 대해서는 아마 전에 여러번에 다룬 적이 있을텐데, 여러분이 올바른 의미와 활용을 꼭 이해하길 바랬어요
I probably covered this expression before several times.
But I just wanted to make sure that you understood the correct meaning and usage.

later : 나중에

현재 시점에서 미래(나중에)를 기약하며

☞ I'll see you (again) later

☞ I'll call you back later

현시점에 (시간의 양) 후에 /뒤에 에는 later 를 쓰지 않음 --- > 시간의 양과 함께 언급할 땐 'in' 을 떠올려야함

"며칠(시간의 양) 뒤에 보자"

5분 뒤에 보자
I'll see you fine minutes later (X)
I'll see you in five minutes (O)

1시간 뒤에 다시 전화할게요
I'll call you back in an hour

과거에 있었던 일에 대해서 말할때는 씀(later = after that)

걔들 2008 년에 처음 만났었는데, 불과 몇년 후에 결혼햇어
They first met in 2008, (just) a few years later, they got married
(They got married just a few years later)

내 가족들이랑 나는 한국으로 1994년에 들어왔어요
그리고 몇년후에 IMF 가 닥쳤어요
타이밍이 별로 좋지 않았죠

My failmy and I came back to Korea in 1994.
Just a few years later(after that), the IMF crisis hit.
So, the timing wasn't very good for us

in vs after 의 뉘앙스 차이

몇 년 후에는 다들 잊을 거야
After ten years, everyone will for get about it

몇 년 지나면 다들 잊을 거야
In ten years, everyone will forget about it

in five minutes : 5분 후에/뒤에

after five minutes : 5분 지나면

[Business english] 우선적으로 해야할 일은 ~/ 빠진 내용이 없는지 확인부탁드려요/ 나중에 다시 얘기하시죠 영어로

꼬북칩조아 — Tue, 21 Mar 2023 22:48:04 +0900

<가장 우선적으로 해야할 일은>

A: 쉽지 않을거야

B: 응 자 가장 먼저 해야 할 일은 - 사람들한테 알려서 가장 우선적으로 해야할 일로 만들어야 돼

A: 맞아. 그리고 참고로, 킴이 이번 달에는 없을 거니까 일손이 많이 부족해

B: 맞아. 그리고 그 얘기 하는 김에, 일을 어떻게 나눠서 할건지를 좀 의논해 봤으면 좋겠어

C: 일 얘기가 나와서 말인데, 야근에 대한 수당은 받는 거야?

B: 그럴일은 없을 듯

C: 그거 참 힘이 되네

A: It's not going to be easy

B: Mm-hmm. So, (the) first order of business - We need to get the word out and make sure that this is on the top of everyone's to-do list

A: Right. And for the record, we're severely short-handed since Kim won't be here for the rest of the month.

B: That's right. And while we're on that subject, I'd like to discuss our division of labor.(R&R, role & responsibilities)

C: Speaking of labor, do we get paid for overtime (work) ?

B: I doubt it

C: Well, that's encouraging

*first order of business : 가장 먼저 해야할 것 / 가장 먼저 처리할 것 (일의 순서에 있어서 가장 먼저 해야 하는 것에 대해 말할 때)

(the first thing we need to do / take care of / deal with 와 의미적으로 유사하나 비교적 formal 하게 말할 때)

*get the word out : 여기서 word 는 "말" 을 의미

* make sure that something is something : 무엇을 꼭 반드시 (~ 상태로 만들다 / ~게 되게끔 하다)

* for the record : 참고로(여기서 공식적으로 얘기 할께 라는 의미 포함; 분명히 얘기해 두는데)

*short-handed : 일손 부족(일적으로)

(understaffed/ short-staffed 와 유사하지만 시스템 적으로 리소스가 부족할 때)

*while we're on that subject : 그 주제로 얘기 나온 김에

(as long as we're talking about this ..)

*speaking of labor : '좀 다른' 얘기로 이어갈 때 (1차원적으로 떠오른 얘기 할 때)

<빠진 내용이 없는지 확인했으면 좋겠습니다>

이번 주에 우리가 할 일들을 목록으로 만들어 봤어요

오늘 아침에 얘기한 내용을 다 넣으려고 했는데, 같이 검토해서 빠진 내용이 없는지 확인했으면 좋겠어요

시간 순서대로 최대한 정리하려고 했는데, 그것도 수정이 필요하다고 느껴지면 얘기해주세요

Ok. I've put together a list of the things we need to do this week.

I tried to include everything we discussed this morning

But I'd like it if we could go over it together and make sure nothing has been left out.

I did my best to put it in chronological order but please let me know if you feel (think) we need to make any changes to that as well.

*put together (made) : 이미 존재하는 정보들로부터 구성을 했다는 뉘앙스

*include : 포함하다 / 포함시키다

*I'd like it if we could do something together : 함께 ~ 했으면 좋겠습니다 ( I wanted 보다 formal 하게)

*go over : 검토하다

*make sure ~ : ~를 확실히 하다

*be left out / leave out something : 뭔가를 빼놓다 빠트려 놓다

*put it in chronological order : 시간 순서대로 정리하다(put it)

*make changes to something : ~에 변화를 주다 /수정하다/ 변경하다

<나중에 다시 얘기해도 될까요 >

Can I get back to you on that(this matter, this issue) ? : 이 주제에 대해서 내가 다시 연락해서 다시 얘기를 해보자

(소통을 다시 이어가는 것이 이메일/전화/직접만나는 것을 모두 포함함)

내가 준비가 안돼있다거나, 다른 일로 지금 못한다거나, 좀 더 준비를 하고 다시 얘기를 했음 한다거나.

Let's talk about this later 는 약간 지금 중요하지 않으므로 나중에 얘기합시다 라는 뉘앙스도 있음

*get back to someone

ex) Thanks for getting back to me so soon : 다시(이어서) 소통(피드백)을 해줘서 고마워

ex) Sorry for getting back to you so late : 그 소통(피드백을) 좀 늦게 줘서 미안해

I'm sorry for the short notice : 준비할 시간을 너무 못줘서 미안해요

Thanks for getting back to me on such short notice : 준비할 시간이 짧았음에도 이렇게 피드백 줘서 고마워요

*(on) (such) short notice : 알림이 너무 짧았어서

자 다 오신것 같네요. 시작하는 게 좋겠습니다

오늘 저희가 다룰 내용이 많습니다

다들 새로운 업무 평가 시스템에 대해서 궁금하신 것이 많을 것으로 알고 있고 진행을 하면서 최대한 모두 다루도록 하겠습니다.

하지만 그것에 들어가기에 앞서 먼저 확인하고 싶은 것이 몇가지 있습니다.

Ok, I think everybody is here. I think we should get started.

We have a lot to cover today.

I know you all have a lot of questions about the new performance evaluation system and we'll try to address as many of them as we can as we go along.

But before we get into that, there are a couple of things that I'd like to go over first.

*cover : 어떤 '범위'를 다룬다라는 의미

*address : 'question' 과 어울림 (단순히 어떤것을 해결하는 의미 외에도, 해당 이슈에 대해 "생각하고 의논한다"라는 의미를 내포)

(deal with / handle with /cover + question 은 다소 어색함)

+ 다른 의미로 사람을 address , 사람에게 문서를 address 하는 표현도 있음

*go over : cover 과 의미상 유사하나, 일일이 훑어보면서 검토한다 라는 것을 강조하는 의미

※ 출처 : 유튜브 "라이브 아카데미"

https://www.youtube.com/watch?v=OGQUPXKpKV0&list=PLIsIUJcT0HIWujnempwzDUjepTu-AGxDa&index=9

https://www.youtube.com/watch?v=9P9vPSscFKc&list=PLIsIUJcT0HIWujnempwzDUjepTu-AGxDa&index=12

[Business english] 일정을 앞당기거나 미룰때/ 의견 받아보다 영어로

꼬북칩조아 — Mon, 20 Mar 2023 23:00:57 +0900

일정을 앞당길 때 'move up'

제가 예약한 일정을 더 일찍으로 변경하고 싶습니다

☞ I would like to move up my appointment to an earlier date

우리가 회의를 화요일로 앞당겼어요(능동)

☞ We moved up the meeting to Tuesday

회의가 화요일로 앞당겨졌어요(수동)
☞ The meeting has been moved up to Tuesday

회의를 화요일로 앞당겼어요 (애초에 그렇게 할려고한 의도/계획/동기/이유 가 있는 상황일 때)
☞ We got the meeting moved up to Tuesday

사역동사*get something p.p : 어떤일을 완성짓는 것

A: 예약했어?
B: 응 근데 가장 빠른게 다음 주 월요일이래
A: 안돼 너무 늦어. 앞당길 수 있는지 알아봐봐

A: Did you get an(the) appointment ? (An: 일반적 예약, The : 구체적 /특정적인 예약)
B: Yes, but they said the earliest (soonest) is next Monday.
(They said Monday next week is the earliest (soonest))
A: No, that's too late. See if you can get it moved up (see if you can moved up)

*예약
특정 장소나 서비스 (식당/호텔 등) 예약: reservation
사람 (특히, 의사 나 변호사 등)과 진료/상담예약: appointment

*알아보다
see + if : ~ 인지 아닌지
see + what /where/how/how much / why .. : 무엇인지 /어딘지/ 어떻게 하는건지 / 왜그런지
ex ) I'll see if i can do this : 내가 할 수 있는지 한벌 볼께

일정을 미룰 때 'push back' 'postpone'

A: 숙제가 이번 주까지가 기한이야? 다음 주로 미뤄진 것 아니었어?
B: 그랬었는데 시험 기간이랑 겹쳐서 다시 앞당겨졌어

A: Is the homework due this week?
(Is the homework due by the end of this week ?)
Wasn't it pushed back(postponed) to next week ? (I thought it was pushed back(postponed))

B: It was. but it was(got) moved back up because it's test week

*겹친다라는 표현을 한다면..
It (overlapped or conflicted) with test week

어떤 것에 대해 누군가에게 보여 줌으로써 의견 받다 : run something by someone
어떤 것에 대해 얘기 꺼내다 : bring something up (to someone)
누군가에게 무엇(어떤 사실)을 인지시키다 : bring something to somone's attention

A: 이거 꽤 중요해 보이는데, 상사한테 의견 받아보고 뭐라고 하시는 지 저한테 알려주세요
B: 알았어. 오늘 점심 바로 전에 짧게 회의가 있는데 그 때 얘기를 꺼내볼게

(상사와의 회의 중에 / 혹은 마치고 )

B: 아. 한가지 더 보여드리고 싶은게 있는데요 (blah blah ~)

C: 얘기해줘서 고마워요

A: This seems pretty important
Why don't you run it by your boss first and let me know what she says
B: Yeah. of course. I have a short meeting with her just before lunch today. I'll try to bring it up then

(right after the meeting)

B: Oh. There's one (more / other ) thing (that) I wanted to run by you
C: Thanks for bringing this to my attenstion

*give someone a heads up : 누군가에게 heads up 을 하게 해줌
hey thanks for the heads up : 미리 얘기해줘서 고마워

[Business english] 제가 지체만 시킬 것 같아요 / 아직 조율 중이에요, 타협하다 / 언제까지 할까요? 영어로

꼬북칩조아 — Mon, 20 Mar 2023 06:52:42 +0900

< 제가 지체만 시킬 것 같아요 >

I feel like I'll just be holding up the process

(예문)

A: 그래서 어떻게 생각하세요?

필요한거 다 알려줘서 오늘 중으로 완전히 준비시켜 드릴 수 있는데

B: 아 너무 좋은 제안이고 아마 나중에 후회할 것 같은데,

아쉽지만 패스해야 될것 같아요.

시간을 좀 더 갖고 다시 생각해보길 바라시겠지만

제가 지체만 시키는 상황이 될것 같아요

A: So, What do you say ?

I can fill you in on everything and get you up to speed by the end of the day today

B: You know, there's so much that I like about that offer and I'm probably going to reget this (later)

but I'm afraid I'm going to have to take a pass on it.

I know you'll probably want me to take some time to think it over

but I feel like I'll just be holding up the process

*What do you say ? : 제안 후 의견이나 생각을 물을 때 (Casual 한 느낌이나 formal하게 써도 어색하지 않음)

*fill someone it (on something) : something 에 대해 불충분한 것들을 ~에게 채워주는 것

*get someone up to speed : fill ~ in 과 비슷하지만, (도와줌으로써) 다른 사람들과 같은 속도로 할 수 있도록 높여준다는 느낌

*by the the end of the day today : 종료 시점 '이내로'

(first thing tomorrow morning : 내일 첫번째로)

*I'm afraid I'm going to have to do something : 아쉽게도 ~ 해야할것 같다 ( 앞으로 ~해야할 것 같다는 뉘앙스)

(I'm afraid I have to do something: ~할수 밖에 없는 상황이 '이미' 존재)

*pass on it : say 'no' 로도 표현 가능

*hold up the process : 진행을 지체시키다

(I'm sorry I've been holding up the process : 진행을 지체지켜서 죄송합니다)

*미래진행형: I feel like I'll just hold up the process : 지체 시킬것 같다(현재)
I feel like I'll just be holding up the process : 지체 시키는 상황이 될것 같다(미래진행) 라는 뉘앙스 차이

< 아직 몇가지 세부사항들을 조율중이에요 >

We're still in the process of working out a few fine details

< 그들이 중간에서 타협해줄 의향이 있다면, 빨리 진행하고 싶네요 >

If they're willing to meet us halfway, we're very anxious to get things moving forward

(예문)

새 공급처와 계약이 거의 성사되려고 하고 있어요.

아직 몇가지 세부사항들을 조율중이에요

우리가 추가 요청을 몇가지 했는데,

그들이 중간에서 타협을 해줄 의향이 있다면 우리는 빨리 일을 진행시키고 싶어요

We're closing in on a contract with a new supplier.

We're still in the process of working out a few fine details.

We've made some additional requests

and if they're willing to meet us halfway, we're very anxious to get things moving forward

*closing in on something : ~ 에 점차 가까워지고 있다

*be in the process of ~ ing : ~ 하고 있는 과정에 있다

*work out : 조율하다 (구동사), work (things) out with (someone)

*meet someone halfway : 타협을 보다

Come on meet me halfway : 타협좀 하자

*get things moving forward : 일을 진행시키다

<언제까지 하면 될까요? >

When's a good time for you ?

시간 언제가 좋아요? 괜찮으세요?

When's a good time for you ? / When's good for you ?

When's the best time for you ? / When's the best for you ?

가능한 빨리요

As soon as possible

급할 것 없어요. 언제는 할 수 있을때 해주세요

There's no rush. Just whenever you can get to it

편한 시간내에 해주세요 + 하지만 가능하면 빠르게

At your earliest convenience

헤더(header) 파일이 필요한 이유

꼬북칩조아 — Fri, 17 Mar 2023 23:23:37 +0900

헤더 파일은 별도 파일에 구현되어있는 함수와 클래스의 인터페이스를 선언 및 제공하기 위한 용도로 사용됨

즉, 헤더파일은 보통 실제 구현 코드는 포함하지 않고, 프로그램의 API와 같은 형태로 제공되는 용도로 사용됨

Build process 에서 C++ 컴파일러는 헤더파일을 읽어 프로그램 상에서 사용 되는 함수와 클래스를 파악함

별도 소스파일에 존재하는 실제 구현 코드는 object 파일로 컴파일 됨

결국 object 파일은 링킹(linking) 과정을 통해 최종 실행 파일 혹은 라이브러리를 만들어 내게 되는 것

헤더파일들은 여러가 지 소스파일들에서 코드 중복을 방법을 제공하기도 함

예를들면, 한 프로그램이 다른 소스 파일에 정의된 유틸리티 함수를 사용한다면, 해당 함수는 헤더파일에 선언될 수 있으며, 다른 소스파일에서는 그것을 include 함으로써 사용할 수 있게 됨

이렇게 함으로서 코드가 중복이 없는 정제된 코드를 만들어 낼 수 있음

헤더 파일은 build process 에서 프로그램의 요소(component)들의 인터페이스와 구현을 분리하는 방법이며, 코드 중복을 줄일 수 있는 아주 중요한 역할을 함

Header files provide a number of benefits for building C++ programs:

Code organization: Header files provide a way to separate the interface and implementation of a program's components, making it easier to organize and maintain the code.
Code reuse: Header files make it easy to reuse code across multiple source files, as functions and classes can be declared in a header file and included in any source file that needs to use them.
Dependency management: Header files make it clear which entities are used by each source file, making it easier to manage dependencies between different components of the program.

virtual table (가상함수 테이블)이 생성 및 참조 되는 시점

꼬북칩조아 — Fri, 17 Mar 2023 20:52:19 +0900

virtual function (가상함수) 오버라이딩 두가지 규칙

1. 상속된 메소드를 재정의할 경우에는 오리지널 원형과 정확히 일치시킬 필요가 있음

(에외: 리턴형의 공변(covariance)- 리턴형이 기초 클래스에 대한 참조나 포인터인 경우 파생 클래스에 대한 참조나 포인터로 대체)

2. 기초 클래스 선언이 오버로딩 되어있다면, 파생 클래스에서 모든 기초 클래스 버전들을 재정의 해야 함

Abstract class (추상 클래스) 의 특징

적어도 하나의 순수(pure) 가상함수를 가진 클래스

순수가상함수(pure virtual function) : 함수 선언 뒤에 “=0” 붙여서 표현하며 선언만으로 존재

순수가상함수를 포함한 클래스는 객체생성 불가능(기초역할을 하기위해서만 존재)

상속과 오버라이딩(Inheritance and Overriding)

기초 클래스 메소드를 파생 클래스에서 재정의 할때는 일반적으로 해당 기초 클래스 메소드를 virtual 로 선언함

virtual 키워드 사용하지 않을 경우, 프로그램은 참조형이나 포인터형에 기초하여 메소드를 선택

virtual 키워드 사용할 경우, 프로그램은 참조나 포인터에 의해 지시되는 객체형에 기초하여 메소드 선택

※ 주의: 파생 클래스에 하나라도 오버라이딩 된 함수가 존재할 경우, 기초 클래스에 가상 소멸자 선언해줘야 함

virtual 소멸자가 아니라면, 포인터형에 해당하는 소멸자만 호출될 것

(즉, 파생 클래스를 지시하는 경우에도 기초 클래스 소멸자가 호출된다는 것을 의미)

따라서 virtual 소멸자로 객체형에 해당하는 소멸자가 호출된 이후 기초 클래스 소멸자가가 자동으로 호출되게함

정적 결합과 동적 결합(Static binding & Dynamic binding)

정적 결합: 컴파일 동안 일어나는 결합 (초기 결합)

동적 결합: 런타임 동안 올바른 가상 메소드가 선택되도록 하는 결합(말기 결합)

객체에 대한 참조를 사용하여 또는 객체를 지시하는 포인터를 사용하여 가상 메소드가 호출되면,

프로그램은 그 참조나 포인터형을 위해 정의된 메소드를 사용하지 않고,

객체형을 위해 정의된 메소드를 사용하며 이것을 “동적 결합”이라고 함

기초 클래스 포인터나 참조가 파생 클래스 객체를 지시하는 것이 항상 가능하므로 이러한 로직이 중요함

(암시적) 업캐스팅: 기초 클래스 포인터나 참조가 기초 클래스 객체나 파생 클래스 객체를 참조하는 것을 가능하게 함

동적결합이 필요한 이유

이에 대한 해답으로 가상 멤버 함수 개념이 등장

friend (프렌드) 와 virtual function 가상함수)

프렌드는 가상함수가 될 수 없음

멤버 함수만 가상함수가 될 수 있는데, 프렌드는 클래스 멤버가 아니기 때문

이 경우 프렌드 함수 내부적으로 가상 멤버 함수를 사용하게 하면됨

가상함수를 다시 정의하지 않으면, 파생 클래스는 그 함수의 기초 클래스 버전을 사용함

(길게 이어진 파생 사슬 구조라면 가장 최근에 정의된 버전을 사용함)

어떤 함수를 파생 클래스에서 재정의하면 동일한 함수 시그니처를 갖고 있는 기초 클래스 선언만 가리는 것이 아니라,

매개변수 시그니처와 상관 없이 같은 이름을 가진 모든 기초 클래스 메소드를 가림

가상함수 테이블의 생성 및 참조

virtual table 는 컴파일러에 의해 생성됨

생성하는 조건은 클래스 내부에 최소 하나의 가상함수가 정의 되어 있는 경우임

가상함수 테이블은 해당 클래스의 가상함수 리스트를 포함하고 있는 자료 구조를 의미함

가상함수를 포함하고 있는 클래스의 각 객체들은 가상함수 테이블을 가리키는 포인터를 가지는데,

이 포인터는 객체의 생성자에 의해 초기화 되며, 해당 클래스의 가상함수 테이블을 가리킴

객체에 의해 가상함수가 호출되는 것은, 가상함수 테이블 포인터를 이용하여 가상함수 테이블 내에 호출된 함수를 찾아 호출하게 되는 것

가상함수 테이블은 객체 포인터나 참조에서 가상함수가 호출되는 런타임 때에 참조 됨

컴파일러는 가상함수 테이블 포인터를 사용하는 코드를 생성함으로써, (객체의 실제 타입을 근거로 )정확한 함수를 찾아내게 됨

이러한 과정을 dynamic dispatch 라고 하며, 이 과정을 통해 런타임에 객체의 실제 타입으로부터 정확한 함수가 호출될 수 있게 되는 것임

가상함수 및 테이블의 사용은 C++의 핵심 기술중 하나인 다형성(Polymorphism)을 지원함으로써 유연하고 확장성 있는 코드를 구성할 수 있음

결론: virtual table 자체는 컴파일 타임(compile time)동안에 생성되나 조회는 런타임(runtime)에 이루어짐

조합(Composition)과 상속(Inheritance) 차이점

꼬북칩조아 — Fri, 17 Mar 2023 20:25:18 +0900

클래스간 결합도

friend > inheritance > composition ( > aggregation ) > dependency

용어정리 : 상속? 객체? 캡슐화?

상속은 기능의 확장이 아니라, 클래스를 분류하는 수단이다
객체는 책임이 있는 어떤 것이다
캡슐화는 데이터, 인터페이스, 클래스, 시스템 등 구현 가능한 모든 것에 대한 은닉이다. (캡슐화는 가변성에 대한 은닉이다)

상속이 내포하고 있는 문제

상속이란?

기존에 정의되어 있는 클래스의 필드와 메소드를 물려받아 새로운 클래스를 생성하는 기법

중복 코드 제거와 기능 확장을 쉽게 할 수 있음

클래스들 간 계층적인 구조를 만들 수 있음

하위 클래스가 상위 클래스의 구현에 의존하므로 (상위 클래스)변경에 취약

- 상속은 부모 클래스와 강하게 의존하고, 부모 클래스의 캡슐화를 해치고, 결합도가 높아짐

- 부모 클래스 구현을 변경하면, 많은 자식 클래스를 모두 변경해줘야 하는 상황이 생길 수 있음

상위 클래스의 모든 퍼블릭 메소드가 하위 클래스에도 반드시 노출됨(불필요한 메소드 상속받는 문제)

- 상속은 불필요한 부모 클래스의 퍼블릭 메소드가 자식 클래스도 어쩔 수 없이 노출하게 됨

- 특히 공개된 부모 클래스의 퍼블릭 메소드가 자식 클래스의 내부 규칙과 맞지 않을 수 있음

조합은 이 문제를 어떻게 해결할 수 있나?

- 상속과 달리 부분 객체의 내부 구현이 공개되지 않음

- 메소드를 호출하는 방식으로 퍼블릭 인터페이스에 의존해서 부분 객체의 내부 구현이 변경되어도 비교적 안전

- 부분 객체의 모든 퍼블릭 메소드를 공개하지 않아도 됨

조합하고 싶은 클래스의 인스턴스를 새로운 클래스의 private필드로 참조,

그 다음 인스턴스의 메소드를 호출하는 방식으로 구현

조합하면 부분 객체의 캡슐화를 지킬 수 있음

조합은 부분 객체의 퍼블릭 인터페이스에 의존함

조합은 부분객체의 모든 공개 메소드를 노출하지 않아도 됨

상속과 조합을 어떻게 사용해야 할까?

상속의 목적

서브 타이핑 (다형적 계층구조 구현) - 부모 자식 행동이 호환

서브 클래싱 (다른 클래스의 코드 재사용) - 부모 자식 행동이 호환 x

상속을 고려할때

1. 두 객체가 서로 is-a 관계인가 (조합은 has-a 관계)

2. 클라이언트 관점에서 두 객체가 동일한 행동을 할 것이라 기대하는가

결론: 단순히 코드 재사용하려면 조합, 동일하게 행동하는 인스턴스를 그룹화 하려면 상속.

[Business english] 생각이 바뀌시면 ~ / 대화로 풀어나가죠 영어로

꼬북칩조아 — Fri, 17 Mar 2023 06:45:10 +0900

#직장영어1

당신이 준 정보를 가지고 견적을 낼게요

대략적인 견적이 되겠지만 얼마가 들지 대충 감은 올거에요

그 가격이 너무 높다 싶으면 다른 방법을 찾아볼 수 있을 거 같고요,

그런게 아니면 누군가를 보내서 더 자세히 살펴보고 정확한 비용을 결정짓고 나면 최종결정을 하시면 됩니다.

(Casual version)

I'll come up with an initial cost estimate from the information that you've given me.

It'll be a rough estimate but it should give you an idea of about how much you'll be spending.

If you feel that it's too much, we can look for another way.

Otherwise, we'll send someone to take a closer look and determine the exact cost.

Then, you can make your final decision

(Foraml version)

I'll come up with an initial cost estimate based on the information that you've provided

It'll be a rough estimate but it should give you an idea of what to expect

If you have any reservation at that point, we can discuss other options

Otherwise, we'll send someone for a closer inspection and determine the exact cost

after which, you can make your final decision

*what to expect : 무엇을 예상할 수 있는지 (돈을 쓰다라는 말을 직접적으로 언급하지 않음)

*if you have any reservation ~ : 마음이 바뀌면, 다시 생각해보고 싶으면 (주저하게 될때)

*inspection: 단순히 보는 것보다 좀 더 철저하게 확인하는 것

A: 나 이제 가봐야겠다

B: 그래 이번주에 시간나면 좀 알려줘. 막판에 (얘기가) 다른 길로 좀 새서 초반에 나왔던 얘기들을 좀 더 이어서 하고싶어. 중요한 문제에 대한 내용이 나왔던 것 같은데, 그 중 몇가지만 얘기로 좀 풀어가면 좋을 것 같아. 이번 주 중으로도 좋고, 아니면 시간이 지나면 까먹으니까 오늘 이따가도 좋고.

A: Ok. I gotta get going

B: Yeah. Let me know when you have some downtime this week. We got sidetracked towards the end and I want to follow up on some things that came up earlier in our discussion. I think we touched on some important issues and I'd love it if we could just talk through some of them. Sometime this week is fine or maybe even later today while our memories are still fresh.

*downtime : 많이 바쁘지 않은 시간

*get sidetracked : 다른 길로 샜다

(get distracted : 방해를 받았다)

*towards the end : 후반부로 가면서

*follow up on something : something을 계속 이어서 더 나아가다 (보충하다)

*came up : 언급 됐던

*touch on something : 언급됐던(다뤘던; mention 보다 좀 더 폭넓은 느낌; briefly 하게)

(mention은 말로 언급되었던 것을 강조하는 느낌)

*I'd love it we could do someting : ~ 했으면 정말 좋을거 같아요 (자주 쓰는 표현)

*talk through : 문제 해결을 위해 얘기를 나누는 느낌 (talk about : 단순히 얘기를 나누는 느낌)

*sometime this week : 이번 주 중 언젠가

*later today : 나중에, 이따가 (오늘 안으로) (자주 쓰는 표현)

*while our memories are still fresh : 까먹기 전에 (자주쓰는 표현)

[9] 어떻게 알아? /만약 ~ 라면? / 내 관점, 판단, 의견

꼬북칩조아 — Wed, 15 Mar 2023 21:31:23 +0900

출처: 라이브 아카데미 유튜브 채널

A: Hey, how do you know if someone blocked you on Instagram ?

B: I don't know if that's possible. Let me see if I can find something online

OK. Here. It says to run a search using their account name.

If their account doesn't show up in search, it means they've blocked you.

A: What if (that person or they) deleted their account ?

B: You're right. I don't know. I wonder if Kim knows. I'll ask Kim.

* How do you know if ~ : ~ 인지 어떻게 알아

you 는 청자가 아니라 '전체' 를 의미(blocked you 도 마찬가지), if는 '인지 아닌지'

ex) How do you know if it's ready ?

How do you know if it's fully cooked ?

*I don't know if ~ : ~ 인지 모르겠다

*let me see if i can do something : 내가 ~ 할 수 있는지 볼게 (의역: 내가 ~해볼게)

*what if : 만약 ~ 하면 어쩌지?

ex) What if i miss class ?

What if I can't finish all my work tonight?

*I wonder if ~ : ~ 인지 궁금하다 (의역: ~ 일려나)

ex) I wonder if they open on saturdays

I wonder if they allow dogs inside

https://www.youtube.com/watch?v=O7vI-Sj4dMc

<내가 알기로는>

as far as i know (understand)

좀 더 격식을 갖출때: based on what i know, according to what i know, to my knowlege

<내가 듣기로는>

from what i hear, from what i heard (내가 들었던 것은), from what i've heard (내가 그동안 들어왔던 것은)

+ 나에게 개인적으로 전달된 얘기에 대해서는 "I was told that ~"

ex) I was told that it would be the same this year

제가 들은바로는 올해에도 똑같을 거래요

<내가 보기에는, 내 생각에는(In my opinion, I think) >

앞의 두 표현과는 달리 스스로의 '판단'임

The way I see it, As far as I can tell (tell이 판단의 의미를 갖는 경우도 있음)

The way I see it/ As far as I can tell , the timing was the problem

내가 보기에는 타이밍이 문제였어

딱히 큰 문제는 없다 / ~가 늘 불편했다 /어떤 것의 원인이 ~에 있다 영어로

꼬북칩조아 — Wed, 15 Mar 2023 06:54:35 +0900

※ 연습Tip: 한국어 해석을 참고만 하되, 영어로 내용을 풀어가도록 연습

프랭크는 부모님과 사이가 좋은 사람들을 늘 부러워 했다.
그는 부모와 딱히 큰 문제 같은 것은 없었지만 부모와의 돈독한 관계를 가진 사람들을 많이 보면서
자신에게는 없는 부분이라고 느꼈고, 프랭크는 이 사실이 늘 불만이었다.
그의 부모님은 늘 커리어에 충실했던 바람에 프랭크는 자라면서 친척과 보모, 어떨때는 이웃의 보살핌을 받으면서 지낸 시간이 많았는데, 프랭크는 이것이 원인이라고 생각했다

시간을 돌려서(시간이 흘러) 때는 2011년, 프랭크는 29세다
그와 아내인 엘리사는 첫 아이인 애슐리를 갖는다
애슐리가 태어나기도 전에, 프랭크와 엘리사는 이미 함께 내린 결정이 있었는데, 최소한 둘 중 한명은 언제나 애슐리와 함께 있어 줘야 한다는 것이었다.
둘 중 하나는 직업을 그만 둬야 한다는 것이었다.
당시 전기 기술자로 일하고 있던 프랭크는 일을 그만둘 의향이 있었을 뿐 아니라 그것이 자신의 몫이라 주장했다.
당시 고등학교 교사였던 엘리사는 교사로서의 경험을 계속 이어가는 것이 애슐리의 미래에 도움이 될 거라고 생각했으며, 그것으로서 결정은 내려졌다.
프랭크는 일을 그만 두고 주부가 되는 것이었다.
수입이 하나 줄어서 한동안 빠듯할 거라는 것은 알았지만, 가치가 있는 일이라고 생각했다.

그러고 나서 그들을 행복하게 살았을 까요?

Frank had always been envious of people who were very close to their parents.
Although he never had serious issues with his, he never felt the kind of bond that he saw a lot of people have with theirs and this never sat right with Frank.
He attributed this to the fact that his parents were very devoted to their careers leaving Frank to spend much of his childhood being looked after by relatives and babysitters and sometimes even neighbors.

Fast forward to 2011, Frank is 29.
He and his wife Elisa have their first child Ashley.
By the time Ashely was born, Frank and Elisa had already agreed that at least one of them should always be there for Asheley.
This meant that one of them have to quit their job.
Frank, who was working as an electrician at the time, was not only willing to give up his job, but insisted on being the one to do so.
Elisa, who was a high-school teacher at the time, figured that continuing her experience as a teacher would be helpful down the road as Ashley got older, and thus, the decision was made.
Frank would quit his job and become a stay-at-home dad.
They knew things would be tight for a while with one less income but they also knew that it was worth it.

Did they live happily even after that ?

*attribute A to B : A의 원인이 B에 있다

*going back to 2002 : (시간을 거슬러) 2002년으로 돌아가서

*by the time : 시간을 거슬러서 변화되는 일을 얘기할 때 어울림

*had already agreen : 과거 완료, 어떤 일이 일어나기 전에 이미 완료된 상태

*be there for (누구): 누구를 옆에서 지켜주다

*at the time : 당시

back then ?

*figured : 계산을 했다는 느낌 (따져보는 느낌)

*down the road: 시간이 흐르면서, 차차 (in the future)

ex) It would be helpful down the road as I get older

ex) Three years down the road, I hope I will get married : 3년 내에 결혼하고 싶어

My career might be different down the road : 나중에 내 직무는 바뀔 수도 있어

Because believing that the dots will connect down the road will give you the confidence to follow your heart

( 왜냐하면 점들이 언젠가는 이어진다는 것을 믿는 것은
여러분이 여러분의 가슴이 진정으로 원하는 것을 따르게 하는 자신감을 줄 것이기 때문입니다)

*thus: 회화체는 아님, formal 한 느낌 (그것으로써)

*things: 특정 하나를 가리키는 것이아니라 광범위한 영역의 '생활'을 의미

ex) Are things tough these days ? : 요즘 어렵니?

*with one less income : 수입이 하나 줄어서 (dual income household/family : 맞벌이)

https://www.youtube.com/watch?v=a8z62UR5ku8

[7] 대체적으로 / ~면에서는, ~에 관해서는 / 추측해본다면

꼬북칩조아 — Tue, 14 Mar 2023 07:13:48 +0900

[Quick overview]

1. 거의 매일

2. 대체적으로는

3. 이게 사실 약간의 무게감이 더 있다

4. 큰 차이는 없어요

5. 추측해본다면

6. 전형적인

7. 상대가 안되는 것 같아요

8. 무시할 정도이다

9. 각자의 강점이 있다

10. 이게 들고다니기 쉽다 (편하다)

11. 이게 내용물을 더 많이 담는다

12. 무엇에 쓰느냐에 따라 달려있다

1. almost everyday

2. for the most part

3. This one has quite a bit of heft to it actually

4. If i were to guess

5. There's not much of a difference

6. typical

7. I'd say there's no competion

8. It was a very negligible amount

9. They each have their own strengths.

10. This one is easier to carry around

11. This one holds more content

12. It really depends on what you're using them for

이것들은 둘다 물병이고요, 둘 다 거의 매일 쓰는 것 같아요

여기저기 몇가지 작은 차이점을 빼고는 대체적으로 거의 같다고 할 수 있죠

디자인 면에서는 보시다시피 크기가 색상에 있어서 아주아주 비슷하죠.

이게 조금 더 크고 무게감이 꽤 더 있긴 하지만요

소재 부분에서는, 다시 말하지만, 큰 차이는 없어요

추측해본다면, 완전히 똑같은 재료로 만든 것 같아요

있잖아요, 이런 물건에서 흔히 볼 수 있는 스테인리스 스틸이랑 플라스틱 소재요

휴대성 부분에선 상대가 안되는 것 같아요. 이게 확실히 더 가볍고 손에 쥐기도 쉽고, 그냥 들고 다니기가 훨씬 편하거든요

가격의 경우에는, 이게 더 저렵하긴 했지만 (그 차이가) 정말 안 돼서 무시할 수 있는 정도 였어요

자, 실제로 사용하기 좋은 것은... 글쎄요... 정확히 말하긴 어렵네요

나름의 장점들이 있거든요. 이게 비록 가지고 다니긴 쉬워도 내용물은 이게 더 많이 들어가거든요

무엇에 쓰느냐에 따라 다르죠

These are both water bottles and I think I use both almost everyday

For the most part, I'd say they're pretty much the same aside from a few minor differences here and there

Design-wise, they're very very similar in size and color as you can see.

Although this one is slightly bigger and has quite a bit of heft to it actually

On the material side of things, again, there's really not much of a difference

If I were to guess, I'd say they were made from the exact same materials

You know, the typical stainless steel and plastic materials that we normal expect from products like these

In terms of portability, there's really no competition here because this is noticeably lighter and so much (more) easier to grip and just overall just more convenient to carry around.

As far as the price is concerned, I think this one was cheaper, but it was a very negligible amount

Now, when it comes to actual usability.. well, what can i say?

They each have their own strengths. Although this one is easier to carry around, this one holds more content.

So.. It really depends (on) what you're using them for

*heft : to lift, hold, or carry something heavey using your hands

ex) I watched him helft the heavy sack onto his shoulder

*noticeably : in a way that is easy to see or recognize

ex) Ellen had become noticeably thinner

*negligible : too slight or small in amount of be of importance

ex) The difference between the two products is negligible

https://www.youtube.com/watch?v=1sTMOvMYDFg

[6] 최근에 들어서야 / 수동태

꼬북칩조아 — Mon, 13 Mar 2023 07:22:27 +0900

나는 목욕하는 거 좋아해. 안정감을 주거든

항상 좋아했던 건 아니야

사실 젊었을때는 목욕을 거의 안했어.

최근에 들어서야 반 정기적으로 목욕하기 시작했어

어렸을 땐, 제가 항상 바빴었나봐요. 장시간 욕조에 앉아 있다는 거 자체가 썩 내키지 않았던 것 같아요

그런데 최근엔, (다른 모든 것들로부터 떨어져서) 혼자만의 시간을 갖게하는 아주 좋은 방법이더라구요

게다가, 건강에 도움되는 걸 고려했을때, 저녁시간을 보내는 더 좋은 방법이 없는 거같다

I like taking bath. It (really) helps me relax.

I didn't always enjoy it though

In fact, I hardly took baths when I was younger

I've only recentrly started taking baths on a semi-regular basis.

When I was younger, I guess I was just too busy all the time and the idea of sitting in the bathtub for long periods of time was just never all that appealing to me.

But now, I find it to be a great way to give myself some personal time (away from everything else).

Plus, when you consider the added health benefits, I can't think of a better way to spend my evenings

hardly : 빈도(?)

never all that --> not : 강조

I find it to be a great way to do something : ~ 하기에 아주 좋은 방법이더라.

최소한 내가 느끼기에는 난 아내랑 다툰적이 없어요

이유는 그럴만한 가치가 없어서에요

싸울 가치가 없어요. 다툴 가치가 없죠

인생은 싸우면서 지내기엔 너~무 짧아요

아내가 원하는 게 있으면, 그냥 해요

저는 뭐라고 안해요

제가 원하는 건 중요하지 않아요

괜찮아요

왜냐면 다 지나고 나면 상관 없거든요

다 중요한 것들이 아니에요

인생은 너무 짧아요

그리고 여러분도 자신의 파트너와 그렇게 하세요

나중에 가서 분명히 후회할 거게요

싸우는 것은 너무 바보 같은 짓이에요. 하지 마세요

남편이 원하는게 있으면, 그냥 맞춰 주세요

At least as far as I'm concerned, I've never had an argument with my wife

The reason is because it's not worth it

It's not worth fighting. It's not worth arguing

Life is waaay too short to be arguing

When my wife wants something, we do it

I don't argue

What I want is not important

It's Okay

Because in the end, it doesn't matter

It's all insignificant

Life is too short

And you know waht? You should do the same with your partners

You will regret it later on

Arguing is so dumb. Don't do it

If your husband wants to do something, just go along with it.

<수동태>

수동태는 '행위'에 대한 강조.

절차에 대한 설명서와 같은 형태에 자주 사용.

혈액 샘플들이 연구실로 배송된다. 하루에 거의 20회 정도.

그것들은 들어올 때마다, 적게는 20개부터 많게는 50개까지도 될 수 있다

샘플들은 도착하자마자, 분석 되기 전까지 특수 저장 유닛에 보관된다

분석은 컴퓨터와 분석 장비를 이용해서 이뤄진다

한번에 5개 샘플만이 분석 가능하고, 각 분석은 약 3분 30초 정도 소요된다

한번 샘플이 분석 과정을 거치고 나면, 특수 백에 밀봉 돼서 폐기된다

Blood samples are delivered to the lab nearly 20 times a day.

Each time they're brought in, there can be as little as 20 to as may as 50 blood samples

As soon as the samples are received, they are kept in a special storage unit until they are analyzed

The analysis is done using a computer and an analyzing machine.

Only 5 sampels can be analyzed at a time and each analysis takes roughly 3 and a half munutes

Once a sample is put through the analysis, it is sealed in a special kind of bag and discarded.

The analysis is done using ~ : done 이후에 using ~ 으로 이어지므로 ~로 수행된다는 의미 (using ~ 이 없다면 완료됐다는 의미)

복수형 once the samples are put through ~ , they are sealed 도 가능

[5] ~ 때도 마찬가지야 / 말하려고 했던게 / 살짝 걱정되는 부분은

꼬북칩조아 — Fri, 10 Mar 2023 07:03:48 +0900

(스파 얘기)

거기는 못들어봤어요

추천할만 한가요?

처음 가보는 거였어요? 아니면 보통 스파하러 자주 가는 데인가요?

왜 좋은지 알거 같긴해요. 아주 따뜻한 거의 뜨거운 물에 잠겨서.. 한편으론 얼굴은 그런 시원하고 상쾌한 공기에 노출돼있으면..

어떻게 좋을지 알것 같아요. 그런데 저는 목욕체질은 아니에요(실제로 목욕을 하는 사람이었던 적은 없어요)

성인되고 나서 일반적인 목욕(?)을 해본 적이 없는 것 같아요. 전 샤워를 좋아해요

I've never heard of that place

Would you recommand it to people ?

Was your first time there or is that the place that you usually go to for a spa ?

I can imagine why it's good, you know, to be submerged in very warm, almost hot water but having that cool crisp air on your face

I can imagine how that could be good. I've never really been a bath person though

I don't think I've ever taken a proper bath as an adult. I mean, I like shower

*though : 뒤에 이어지는 문장에 though 라고 표현함으로써 앞에서 한 얘기가 사실임에도 불구하고, 그 내용과는 상반되는 내용도 언급

(코로나)

후각이랑 미각이 없다구요?

제 장인어른도 그랬어요

그런 일이 발생해서 안돼셨네요..

제 장인어른이 같은 것을 겪고 계세요

그래서 2주 정도 걸린다는거죠?

아 당신이 후각 돌아오는 데 한 2주 걸리셨다구요?

You've lost your sense of smell and taste ?

That actually happened to my father in law

I'm really sorry that happened to you

My father in law is going through the same thing

So you're saying that it takes a couple of weeks ?

Oh It took you a couple of weeks to get your senses back

(겨울)

너네는 어떤지 모르겠지만, 시간이 지날 수록 점점 더 좌절스러운 것 중 하나는 외출 할때마다 너무 많은 옷을 입어야 하는 것이다

내가 안으로 들어왔을 때도 마찬가지야. 모든 옷들을 치워야 돼.

그게 제가 겨울에서 가장 좋아하는 점이에요:)

아마.. 말하려고 했던게... 겨울에서 가장 안좋아하는 거죠? (~라고 말하려고 하던거 아니에요?)

I don't know about you guys, but one of the things that's becoming increasingly more frustrating as time goes by is having to wear so much clothes every time i go out

It's the same thing when I come back inside. I have to put away all that clothes

That's exactly what i like most about winter :)

Maybe what you meant to say was that that's what you don't like most about winter right ?

*put away : 치우다

(조언)

한국말을 배우려는 외국인이 당신에게 한국말에 대해서 딱 그런 질문을 한다면 뭐라고 하실 건가요?

한국사람들과 한국말을 할 때 두려움을 극복하도록 돕기위해 걔들이 할 수 있는게 뭐가 있을까?

그사람에게 뭐라고 해주실 건가요? 그게 아마 당신의 답이 될거에요

What would you tell a foreigner who is trying to learn Korean, who is asking you that exact same question about Korean?

What is there that they could do to help them(selves) overcome the fear using Korean with Korean people ?

What would you tell that person ? That's is going to be your anaswer

*ask 동사

- 3형식 동사로 사용될 경우: 묻다, 요구하다

목적어로 <형용사류 + 명사> to 부정사구, 의문사절/whether(if) 절만 가능

He asked to have his books delivered to his house

He asked when the next train to Busan would leave.

- 4형식 동사로 사용될 경우: 묻다, ~해달라고 요구하다

직접 목적어로 <형용사류 + 명사> 나 that 절(that /의문사/whether(if)) 만 가능

A porter asked me if I was looking for something

A boy with red hair asked me why I didn't talk with anyone

You must ask yourself to most important question in your life

- 5형식 동사로 사용될 경우: 요청하다

목적보어로 to 부정사구나 V+ed ~ 구만 가능

His father asked his son to tell what he had done during the day

=> who is asking you that exact same question 은 4형식

<걱정>

그래서 그게 지금 살짝 걱정되는 부분이에요

어떻게 깎아야 할지 잘 모르겠어요

왜냐하면 그들이 이 크기에 맞는 샤프너를 팔거 같지 않아서요

칼을 써도 될거 같긴해요

So, that is something that I'm a little worried about right now.

I'm not exactly sure how I'm going to sharpen it

because I doubt that they sell any sharperners that fit this size,

but I guess I could use a knife

https://www.youtube.com/watch?v=FFLyadC1mYA

[4] 주말 계획 /정신차려보니~ / 좋아하는 것

꼬북칩조아 — Thu, 9 Mar 2023 07:14:33 +0900

< 계획, ~만 된다면... >

이번주 주말에 딸애랑 쇼핑가려고 해요

아이가 일로 너무 바쁘면, 미뤄야 해요

딸 시간이 되기만 하면, 같이 시간좀 보내면 정말 좋겠다

I'm planning to go shopping with my daughter this weekend.

If she's too busy with her work, we might take a rain check.

But as long as she has some time, it'd really nice to spend some time with her

이번주 금요일에 애들이랑 글램핑 가려고 해요

(혹시라도) 애들이 아프기라도 하면, 일정을 다시 잡아야 돼요

애들이 컨디션이 좋기만 하면, 가족들이랑 밖에서 시간 보내면 좋을 거 같아요

I'm planning to go glamping with my kids next friday.

If my kids get sick for some reasons, we might have to reschedule.

But as long as they're feeling OK, it'd be really nice to spend some time outside with the family

이번주 금요일에 회식이 있어요

술을 진탕 마시면, 아마 주말내내 골골 댈거(숙취에 시달릴) 같고요

너무 많이만 마시지 않는다면, 이번주 주말에 하이킹 가고 싶네요

I'm planning to go to a work gathering next Friday

If I get really drunk, I'll probably be hungover all weekend.

But as long as I don't drink too much, I'd like to go hiking during this weekend

< 정신차려보니 ~ 하고 있더라고 >

거기 앞으로 며칠간을 안가려고 했어요. 제가 다이어트 중인데 거기 빵집이 있거든요

그런데 며칠 후에, 완전히 까먹고 우연히(실수로) 거기로 지나갔어요

정신차려보니 빵이 가득한 봉지를 한가득 들고 있더라고요

I wasn't going to walk past there for another few days because I'm on a diet and there is a bakery there.

But the other day, I totally forgot about it and walked past there by accident

The next thing i knew, I had a bag-full of bread

- walk past : go by on foot

ex) every day, i sit at my window, watching the children walk past on their way to school

- walk past there 발음 : wal(k) pas(t) 묵음

- for another few days: 앞으로 며칠간

ex) if this continues for another few days, the damage will be limited

- but the other day : 그런데 며칠 후에 (several days ago)

<What's your favorite color ? >

어릴때는 보라색이었어요

지금은 검은색인거 같네요

솔직히 말하면, 좋아하는 색은 상황에 맞는 거에요

핑크색이 상황에 어울리면, 핑크가 가장 좋아하는 색이죠

어떤 상황에서는 흰색이 보기에 정말 좋다면, 그 때는 흰색이 제가 제일 좋아하는 색이에요

그리고 있잖아요. 모든 사람들이 그렇게 느낀다고 생각해요 (그렇게 느끼는 것 같아요)

아무도 확실하게 좋아하는 색을 갖고 있진않죠. 무슨말인지 이해하죠

보라색을 좋아하는 사람은 우울한 경향이 있다고 들었어요. 사실인지는 모르겠지만

사람들은 그들이 원하는 것을 믿을 수 있죠

저도 색과 어떤 감정적인 상태가 어느정도 연관성은 있다고 믿어요

그런데 어떤 사람이 어떤 특성을 갖고 있다고 함부로 말할 순 없다고 생각해요. 단지 그들이 어떤 종류의 색을 좋아한다는 이유로요.

My favorite color.. as a kid.. it was purple

Now i think it may be black

To be perfectly honest, my favorite color is whatever goes well with the situation.

If 'Pink' goes well at that moment. then 'Pink' is my favorite color

In some situation, if 'White' is looks really good, then 'White' can be my favorite color at that moment

And you know what, I think that's the way everybody feels

No one has really a definitive favorite color, you know what i mean.

I've heard those who likes purple tend to be gloomy. I don't know if it's true or not.

People can belive whatever they want

I do believe there're some connection between color and some emotional state.. maybe

But i don't think you can really say that some person has a certain kind of quality just because they likes types of color

In some situation

ex) In some situation, only one direction is needed to be surveilance

whatever goes well with ~

ex) Choose whatever goes well with the flavor and texture of the cake.

딱히 재밌는지 모르겠어 / 예전만큼 신경 안쓰는 것 같아 영어로

꼬북칩조아 — Wed, 8 Mar 2023 07:34:02 +0900

딱히 재밌는지 모르겠어 
예전만큼 신경 안쓰는 것 같아 < they don't put in as much though into ~ >

난 공포 영화 안좋아해
딱히 재밌는 거 모르겠어
근데 어릴 때 전설의 고향은 봤어. 그 프로그램 기억 나?
잘 모르겠는데, 그 프로그램엔 뭔가 재밌는게 있었던 거 같아 (왠지 재밌었어)
그들(제작자들; 불특정)이 현대 버전으로 제작한다면, 한번 볼 거 같아
예전만큼 호러 영화 만드는데 많이 신경 안쓰는 거 같아
아직 그런 영화들에 대한 수요가 있는 것 같아 특히 가볍게 즐기는 스릴을 찾는 어린 친구들한테.
내가 늙어 가고 있는 듯.

I don't like horror movies
I just don't find them very entertaining
Although, I used to watch 전설의 고향 as a kid, do you remember that show?
I don't know, there was something about that show that made it so fun to watch
If they came out with(released/made) a modern version of that show, I might give it a try.
But i feel like they just don't put in as much thought into horror movies as they used to
I guess there still is a place for movies like that,
especially with younger people who are just looking for cheap thrills.
I guess I'm just getting old

※ 가정법 과거 : 상황을 '상상'한 것이므로 불가능한 현실 -> 가정법 과거

If they came out with(released/made) a modern version of that show, I might give it a try.

- 가정법 현재: 확률이 반반 (조건법)

If S + V(현재형 또는 원형) , S+ will/shall/can/may + V

그가 정직하면 나는 그를 고용할거야
내일 비오면 거기 안갈거야

If he is honest, I will employ him
If it rains tomorrow, I will not go there

- 가정법 과거: 불가능한 현실이나 현재와 반대되는 상황 표현; 만약 (과거에) ~ 라면, (과거에) ~ 할텐데

If S + V(ed;과거) , S + would/could 등 + V

내가 키가 컸다면, 농구를 할텐데
날씨가 좋았다면, 쇼핑 갔을 텐데
그녀차 차를 가져온다면, 학교에 정시에 갈수 있을 텐데

If I were tall, I would play basketball
If the weather were fine, I would go on shopping
If she brought the car, I could go to school on time

- 가정법 과거 완료: 과거 특정 시점 이전에 발생한 일, 과거 사실과 반대되는 것을 가정; 만약 ~했더라면, ~했을 텐데

If + S + had pp, S + would/could + have pp

누군가가 날 태워줬었다면, 나는 콘서트 갔었을 텐데
내가 그녈 돕지 않았었다면, 그녀는 과제 못 끝냈을 거야
내가 그렇게 슬프지 않았었다면, 나는 다시 일하러 갔을 거야

If someone had offered me a ride, I might have gone to the concert
If I hadn't helped her, she couldn't have finished the assignment
If I hadn't been so sad, I would have gone back to work

- 가정법 미래: 미래에 일어나기 어려운 상황, 실현 가능성이 낮은 상황; (가능성 없지만) ~ 한다면 ~ 할텐데

If S + should + V , S + will/can/may/should + V

만약 내일 비가 온다면, 워크숍은 안할텐데
내가 널 다시 만난다면, 기쁠텐데
만약 복권에 당첨된다면, 난 백만장자가 될거야

If it should rain tomorrow, the workshop would not be held
If I should meet you again, I would be happy
If I should the lottery, I will be a millionair

- 혼합 가정법 미래: 과거와 현재 시간 혼합; 조건절에 과거완료 주절에 과거형 , 주절에 now, today 같은 현재 시점에 대한 단서

; 만약 (과거에) ~ 했었다면, (지금) ~ 할 텐데

If S + had pp , S + would/could 등 + V

내가 고기를 더 일찍 해동시켰더라면, 지금쯤 점심 식사가 준비됐을 텐데
만약 네 병이 낫지 않았더라면, 나는 걱정했을 거야
만약 내가 더 연습을 했었더라면, 지금쯤 운전 면허를 갖고 있을 텐데

If I had defrosted the meats earlier, lunch would be ready now
If your illness hadn't healed, I would be concerned about you
If I had practiced more, I would have a driver's license now

※ I feel like 와 I think

I feel like 는 인상(impression)

I think 는 의견 (opinion)

시작은 좋았는데 ~, ~ 부터는 / ~하는 것처럼 영어로

꼬북칩조아 — Fri, 3 Mar 2023 06:31:10 +0900

시작은 좋았는데 < It started off really well >
~때문이었는진 모르겠지만 < I don't know if it was becase of
~부터는 ~ 시작했어 < It wasn't until the 4th or 5th episode that I started ~

시작은 좋았어
이국적인 설정 때문이었는지 모르겠지만, 처음 몇개 에피소드들은 재밌었어.
(그전까지는 괜찮다가) 4,5 화부터는 약간 답답해지기 시작했어.
그러니까, 나 이런거 꽤 잘 참는 편인데
그런데 이야기에 보탬이 되지 않는 것들이 좀 있다고 느꼈고 오히려 좀 거슬렸어.
첫 시즌 중간쯤 가니까, 문제점들이 나한테 좀 보이더라구.
여기 저기에서 좀 짜깁기 한거 같았어. 독창성이 없었어
첫 시즌이 끝날 때쯤 되니까 계속 봐야하는 건지 모르겠더라고

It started off really well
I don't know if it was because of its exotic setting, but the first several episodes were really interesting
It wasn't until the 4th or 5th episode that i started to get a little antsy.
I mean, I'm pretty patient when it comes to these things,
but i feel like there were some parts that didn't really add to the story, and felt more like distractions
About half way through the first season was when the cracks (really) started to show for me.
It felt like they were tracking bits and pieces from here and there. It just lacked originality.
By the time the first season came to an end.
I wasn't sure if I should(wanted to) keep watching

※ It wasn't unitl ~ that 관련

1. It wasn’t until 1984 that the company changed its name to Nissan.

2. It was in 1984 that the company changed its name to Nissan. (your "Polish version")

3. In 1984 the company changed it's name to Nissan.

-> All 3 sentences are correct and normal in English. They all describe the same event.

But they say different things about that event. Sentence 3 just describes the event.

Sentences 1 and 2 emphasize a specific thing about it

Q. So any information can be expressed this way?
'I met my wife in 1990. = It wasn't until 1990 that I met my wife'
I believe I emphasize the fact the I met her in 1990, not earlier, in the second sentence, right?

A. correct

distractions

By the time : 계속 되던 것이 ~ 때쯤

20대에게 전하는 메세지

모든 걸 너무 심각하게 받아들이지 말고, 젊을때 최대한 젊은걸 즐겨라. 하고싶은건 다 하도록 노력해라
왜냐하면 젊을수록 잃을게 적기 때문이야.
최대한 여행 많이 해라
살면서 돈은 언제든지 나중에 벌수 있으니, 돈을 쫓으려고 너무 노력하지 마라
건강을 챙기기에 늦은 나이란 없으니, 규칙적으로 운동하는 습관들여라.
새로운 사람들을 만나는데 주저하지 마라.
가능한 빨리 돈 관련 지식을 쌓아라
이 과정이 오래 걸리겠지만, 인내하고 성취해라.

Try not to take things too seriously and enjoy your youth while you have it and try to do everything you want
because you tend to have less to lose when you're young. (because the younger you are the less you have to lose)
Travel as much as you can.
You can always earn money later in life
so don't worry too much about making a lot of money (so don't try so hard to cahse money)
You're never too young to start caring for your health, so make it habit of working out regularly.
Never hold back from meeting new people.
Grow your financial literacy as soon as possible
This process can take a lot of time, be patient and get after it.

tend to + V : be likely to do something; to happen often;

later in life : 살면서 나중에

You're never too young to : ~하기에 절대 어리지 않다

get after it/them : usually used as encouragement for someone to “start doing something;” occasionally it can also include the action of physically running after someone

Small talks

<주제: 샤워>

스트리밍하기 바로전에 샤워했다. 한시간도 안된 시점에
일주일에 샤워 2번정도 한다. 자주 있지 않는 특별한 일이다
그래서 모자써서 망치지 않을겁니다

I just took a shower right before the stream
like not even an hour before the stream
I only take like two showers a week
So it's a special occurrence for me
So I'm not going to ruin it by wearing a putting on a hat

특별한날.. 내 남편과 비교해서는 꽤 자주 샤워하네요
Special day... you take a shower pretty often compared with my hubby..
에이 ~ 그럴리가요
Come on That's not true

<머리 기른지 얼마나? >

음 잘 모르겠지만 4~5 개월 정도 된거같아요
I think it's been like.. I don't know..
It feels like .. I mean... I'm not sure but it feels like it's been like 4 or 5 months

<올해결심>
몇가지 하고 싶은 것들이 있지만, 올해 안에 할 필요는 없어요
내가 항상 하려고 하는 것과 거의 같은 것들이에요

There are things that I would like to do, but not necessarily within this year
It's just pretty much the same thing that i always try to do

<영어 공부>
오늘 함께해서 정말 좋네요
싱가폴에서 오는 VIP와 중요한 미팅이 있는데, 오랫동안 (영어) 연습을 못했어요.
오늘밤 목소리한번 내볼게요

It's really good to have you here today
I have an important meeting with VIP from singapore, and haven't practiced for a long time,
let me speak out tonight

제가 항상 말하듯이, 연습하는 좋은 방법은 .. 특히 특정 상황에서 영어를 사용하는 것을 준비할 때...
당신이 말하려고 생각하는 것들로 리스트를 만드세요
질문이 될수도 있고, 설명해야 하는 것들일 수 도 있어요. 그것들의 리스트를 만드세요
한국어로 먼저 써보고 그리고 그것들을 전부 영어로 바꿔보세요 그리고 스크립트 처럼 사용해보세요
(약간) 당신이 인터뷰 준비할 때 하는 것 처럼요
그게 우리가 인터뷰 준비하는 방법 아닌가요?
논의 됐으면 하는 것들로 리스트를 만들잖아요.
배우가 스크립트 준비하는 것처럼요

As i always say, a good way to practice especailly when you're preparing...uh... to use english in a specific kind of setting... make a list of things that you think you might talk about..
it could be questions or things that you have to expalin... make a list of it
write it out in Korean first and then try transferring that all into English and then you use that kind of like a script
you know kind of like how you prepare for an interview
Isn't that how we preapre for interview?
we make a list of things that you know that are likely to be discussed
you know like an actor preparing a scirpt

<노래 좋네요>
모르겠네요. 웹사이트에서 찾았어요. 제가 클래식 음악을 좋아해서 좋다고 생각햇어요
제가 사실 클래식 음악을 아주 좋아하거든요
많이 들어요. 좋다고 생각해서 play list 에 추가했어요. 그래서 있네요.
I don't know. I just found it on the website and i thought it was nice because i like classical music
I love actually love classical music.
I listen to it a lot and i thought it was nice, so I just threw it in my playlist so it's there

그거야 자기 취향에 전적으로 달린거죠
That totally depends on your taste

<Copyright>
내가 알기로는 저작권은 작곡가의 수명에 70년을 더한 거에요
내가 이해하기로는 그래요.

From what i understand, copyright is for the duration of the composer's life plus 70 years
That's the way I understand it

<영화>
마션? 멧데이먼 나오는 거?

Martian ? Is that the one with Matt Damon

<샤워 시간>
샤워해야 하는데.. 계속 들어야되네요.

I need to take a shower. But I'm keep listening

샤워 10분이면 끝나죠. 8분 30초 정도 남았네요. (그러면) 샤워 할 수 있죠.
저는 5분이면 샤워 해요
정말요? 저는 3초면 옷 벗을 수 있어요

You can take a shower in 10 minutes
We have about eight and a half minutes
You could take a shower
It only takes me like five minutes to take a shower
Really? like me,,, I can strip in three seconds

5분이면 충분하쥬

It's five minutes enough time

그래요 5분이면 완전 충분한 시간이죠.. 아 잠깐 여자면 얘기가 다르지..
여자는 보통 좀 더 오래 걸릴 거 같아요
남자는, 나는 5분 미만이라고 봐

Yeah five minutes is totally enough to take a shower i think
Oh wait.. Unless you're a girl
I guess take the showers usually take a little longer for a woman
For men, I say, no longer thatn 5 minutes

<기타>

I'm still not used to it myself
So i don't blame you (for felling awkward)

I'm not the right person to be give you advice about ~

후회,어차피,게다가 /현재로서는 이게 최선 / ~ 일수도 있다 영어로

꼬북칩조아 — Fri, 20 Jan 2023 07:02:09 +0900

유튜브 "라이브 아카데미" 복습을 위한 블로그

# 1. 후회, 어차피, 게다가

*사오다: buy / get / pick up / bring

Oh, shoot, I only got three

I should've picked up another one. (후회를 나타내는 표현)

I didn't know(think) you would be there (too) (know - 정보, think - 내 판단 / too 가 추가되면 너'도' 여기 있을 줄 몰랐다)

No, it's OK

I was about to leave anyway. (was about to 는 "이제 막" 좀 더 절묘한 타이밍에 대한 표현)

(I was going to leave anyway)

Besides, I'm trying to cut down on caffeine these days.

So, you guys go ahead

#2. 현재로서는 이게 최선

차를 사려고 알아보고 있는 중이에요

개인적으로는 SUV 처럼 큰 차를 좋아하지만, 지금은 그건 좀 어려울 것 같아요

중고시장을 알아보는 방법도 있지만 그럴 경우 결함이 있는 것을 사게 될 위험이 있어요

제가 차를 잘 몰라서요

그래서 현재로서 가장 좋은 것은 새 경차를 사는 거에요

작긴하겠지만 그래도 새거일테니까요

I'm looking to buy a car.

Personally, I prefer bigger cars like SUVs but I just can't swing it right now.

I could look into the second hand market. But then I would have to risk getting a faulty one

because I don't really know cars.

So, at the moment, I think my best option is to get a new subcompact car.

It'll be small but at least it'll be new

be looking to (do - sth) : 무엇을 하기위해서 알아보고 있는 중이다\

(e.g)

Do you know anyone who is looking to buy a car ?

I can't swing it : I can't afford it 보다 조금더 casual 한 표현 (~할 여유가 없어)

I could do somghing : 내가 원하기만 하면 (마음만 먹으면 그렇게 할 수 있다)

but then : 그랬을 경우에는

I would have to risk doing something : ~할 위험을 감수해야 한다

At the moment, I think my best option is ~ : 현재로서는 최선은

저는 제 강아지들 때문에 길게 여행다녀오는게 쉽지 않아요.

그들을 대신 돌봐줄 수 있는 사람이 주변에 없거든요

펫 호텔에 묵게 하는 방법도 있긴 하지만, 그러면 그들을 모르는 사람한테 맡겨 놓고 나만 놀러가는게 불안할 것 같아요

그래서 더 좋은 방법을 찾을 때까지는 강아지들을 데리고 짧게 여행을 다녀오는 수 밖에 없어요

It's not easy for me to go on long trips becase of my dogs.

I don't know anyone who can look after them for me.

I could have them stay at a pet boarding facility but then I wouldn't feel safe about leaving them behind with a stranger while I'm out having fun.

So, until I can find a better way, I can only go on short trips and take my dogs with me.

could : 마음만 먹으면 그렇게 할 수 있지만

would : ~ 할 것 같다

leave them behind with a stranger

I can only do somthing : ~ 할 수 밖에 없다

#3 It could be 표현

3-1 ~ 일 수도 있다

네 말이 맞을 수도 있겠다

You could be right about that

You could be right

내 말이 틀릴 수도 있어

I could be wrong

I could be wrong about that

3-2 It could be that + (full sentence 사실일 수도 있는 내용)

Example1)

Of course, she might(could) just be tired

-> It could be that she's just tired

Example2)

I don't know what's wrong with my cat

She's just been lying around all day not doing much

So I'm thinking of taking her to the vet later today

It could be that she's just tired, but I don't know

I don't want to take any risks (chances)

※ 조동사 + have + pp 표현의 절반 가까이를 It could be that + full sentence 로 표현 가능

Example3)

그 사람이 까먹었을 수도 있으니까 네가 연락을 해봐

He might(could) have just forgotten. So just call him

연락해봐 그사람이 까먹었을 수도 있느니까

Call him because he could've (might've) just forgotten

-> Call him. It could be that he just forgot

Example4)

걔가 그냥 겁이 났던 것일 수도 있어

He might've(could've) just been afraid (scared)

He might've(could've) just gotten scared

-> It could be that he was just scared

-> It could be that he was just nervous

※ (주의) It could be that + full sentence 로 대체 안되는 예 (가정법 표현)

단순히 상황에 대해 해석을 하면서 추측하는 것이 아니고, 가정을 하는 상황이므로

If I had studied harder when I was a student, I could've gotten a better job

#4 (최근의 변화를 인지하고 있는 상황에서) 안부 묻기

4-1 (상대방이 힘든 시간이 겪고 있는 것을 알고 있을 때, 걱정하는 뉘앙스) 요즘 좀 어때?

How are you holding up ?

4-2 (이사, 이직, 이민처럼 새로운 환경에서 적응하고 있는 사람에게 하는 안부 묻기)

How are you settling in?

4-3 (최근에 어떤 물건을 사서 쓰고 있다거나, 어떤 서비스를 이용하기 시작한 사람에게 묻는 안부)

(차를 샀다거나, 새로운 보모를 이용하고 있다거나, 의사를 바꿨다거나, 치료법을 바꿨다거나)

How is your new car working out for you?

How is the (your) new nanny working our for you?

How is the (your) new doctor working out for you?

How is the therapy working out for you?

4-4 (상대방과 최근에 사이가 안좋았던 제3자와 관계 회복에 대해 묻는 안부)

How are things with your wife (daughter) ?

[BBC Leaning english] The hidden life of buffets

꼬북칩조아 — Mon, 16 Jan 2023 18:29:41 +0900

Expressions

[1] I only managed to finish three or four plates…well, maybe five!

(해석) 세개나 네개 음.. 아마 다섯개까지는 끝냈(먹었) 던 것 같아

※ managed to: 어떤 일에 대해서 노력을 해서 뭔가 해내는 느낌

(e.g)

Do you think you could manage somehow to slip it in ? (어떻게 해서든 그것을 할 시간을 낼 순 없나요?)

I could manage to make it (나는 그것을 해낼 수 있었어요)

I could manage to be there on time

I didn't want to do that but Jake managed to pursuade me to go

We barely managed to finish it (우리는 그것을 가까스로 끝냈어요)

[2] usually too much is cooked, and buffets have been criticised for waste.

(해석) 보통 너무 많이 요리되고, buffet는 낭비하는 것으로 비판당해왔다

※ All 은 전부를 묶는 느낌-- 복수, Every 는 전체 중 개별을 지칭하는 느낌-- 단수취급

All + (셀 수 있는 명사 - 복수명사) or (셀 수 없는 명사 - 단수명사)

- All my plants have died

- All human beings are fallible

- All the furniture is crafted from natural materials (셀수 없는 명사)

Every + 단수명사

- Every move was painful

- Every job has its difficulties and frustrations

※ 셀 수 없는 것은 단수 취급

many + 복수명사 (셀수 있는 명사)

- Many diets methods fail because they are boring

- Many insects species are banded black and yellow

much + 단수명사 (셀수 없는 명사)

- I don't have much money with me

- Much of the region is lowland

※ 셀 수 없는 것은 단수 취급

a few + 복수명사 (셀 수 있는 명사)

- It only took a few seconds

- I need a few things from the store

a little + 단수 명사 (셀 수 없는 명사)

- she gave a little laugh

- Combine the eggs with a little flour

※ 셀 수 없는 것은 단수 취급

few + 복수 명사(셀 수 있는 명사)

- There are few empry seats

- Very few people know that

little + 단수 명사 (셀 수 없는 명사)

- There was very little room to move

- I understood little of what he said

※ criticise for : ~ 에 대해 비난하다

[3] The word ‘buffet’ originated from the French name for the table on which food was served, but buffets themselves don’t come from France. So in which country did buffets begin?

(해석) buffet 라는 단어는 프랑스 이름인 음식이 놓인 테이블에서 유래됐다. 그러나 buffet 그 자체는 프랑스에서 온 것이 아니다.

어떤 나라에서 buffet 가 시작됐나요?

※ originated from

※ begin in

[4] John shares his observations on human buffet behaviour with BBC

(해석) John 이 BBC에 buffet 에서의 사람 행동에 대해 관찰한 내용을 공유한다

※ share with + so / share + sth + with + so

(e.g)

share a table with another at a restaurant

Excuse me, but would you mind sharing your table (with me)?

I share a room with my older sister

※ observation on / about

But I think that's a pretty astute observation on his part (그런데 나는 그것이 그의 입장에서 꽤 영리한 관찰이라 생각한다)

[5] There are different people that treat buffets in different ways.

(해석) buffet를 다른 방식으로 대하는 사람들이 있다

[6] Some people think this is a great opportunity to try little bits and lots of everything, and we come back as many times as I like.

(해석) 몇몇 사람들은 이것이 모든 것을 조금씩 맛볼(try) 수 있는 아주 좋은 기회라고 생각한다. 그리고 우리는 원하는 만큼 돌아 올 수 있다

(e.g)

Some of us try a little bit of everything, some of us have a big helping of one or two things

(우리중 몇몇은 모든것을 조금씩 시도하고, 몇몇은 한두개를 크게 돕는다)

The best thing you can do is to try a little bit of everything, and you'll eventually find something you like.

(네가 할 수 있는 것중 가장 좋은 것은 조금씩 다 해보는 것이다, 그리고 너는 결국 네가 좋아하는 것을 찾게 될 것이다)

[7] And other people just - whether they don't like getting up and down, which is understandable from their table - just want to pile it high, and people they want to getvalue for money.

(해석) 그리고 다른 사람들은 단지 앉았다 일어나는 것을 싫어합니다. 그들의 테이블에선 그게 당연한거죠. 단지 포개서 쌓고 싶어하고, 가성비를 찾고자 하죠.

[8] if you're paying $100, $200 a head for a buffet, you're gonna pile it up high and take the most expensive things you can you know, and get your money's worth.

(해석) buffet 에서 일인당 100, 200달러를 지불한다면, 당신은 높이 쌓고 당신이 알 수 있는 가장 비싼 것을 가져올 것이다. 그렇게 가성비를 갖는다

[9] If you pile something up, you gather a large amount of it into one place to build what’s called a pile.

(해석) 당신이 뭔가를 쌓는다면, 당신은 많은 양을 한 장소로 모을 것이다 이른바 pile이라고 불리는 것을 만든다

[10] The richer the people getting married, the bigger the buffet, sometimes inviting as many as five thousand guests. If each guest eats around six dishes, we’re taking about a seriously big buffet!

(해석) 사람들이 호화롭게 결혼할 수록, buffet는 더 커진다. 때때로 5천명의 게스트를 초대하기도 한다. 각 게스트들이 약 6접시씩 먹으면, 엄청 큰 buffet 를 하게되는 것이다

※ the 비교급 S + V, the 비교급 (S + V) : ~ 할수록 더 ~ 하다

접속사 as 로 표현 가능 (the 사라지고, 비교급은 제자리로 감)

The more you work, the more you earn = As you work more, you earn more

주의사항

1. 형용사 부사 올바른 비교급 형태쓰기

The more rich(->richer) he gets, the more he wants

The expensiver(-> more expensive) the smartphones is, the more features it has

2. more(less) 부사(형용사) 형태는 항상 함께 움직임

As he got more stressed, he ate more

-> The more he got stressed, the more he ate (X)

-> The more stressed he got, the more he ate (O)

3. 형용사적으로 쓰인 more가 명사를 수식할 때는 함께 움직임

As we read more book, we learn more.

-> The more we read book, the more we learn (X)

-> The more books we read, the more we learn (O)

4. 어순: the 비교급 S + V, the 비교급 (S + V)

The higher climbed we, the thinner the air was (X)

The higher we climbed, the thinner the air was (O)

※ take 동사 6가지 의미

1. 잡다 취하다, 차지하다 (획득)

- I have already taken some action (이미 조치 취했다)

- I took the prize in the audition (오디션에서 상 탔다)

- Can you take my hand now ? (지금 내 손좀 잡아줄래?)

2. (사물) 갖고가다 , (사람) 데리고 가다

- I'll take you by car a little later (좀 이따가 차로 바래다 줄게)

- Be sure to take an umbrella with you (우산 꼭 챙겨가)

3. 받다, 받아들이다

- We take it for granted now (우리는 이제 그걸 당연하게 받아 들인다) *for granted : 주어진 것으로

- Do you take credit cards here? (여기 신용카드 받나요?)

4. (시간) 걸리다

- It takes an hour to get to work

- How long does it take from here ?

5. (약 등) 복용하다 (약 복용에 eat이나 have 사용하지 않음)

- Taking medicines isn't always good

- Why don't you take some painkillers?

6. (교통수단) 타다 , 타고가다

- I would rather take the bus (버스타는게 낫겠어)

- I'm going to just take a subway (그냥 지하철 타고 가려고)

[11] They are out to impress - they want to ‘wow’ the guests - knock their socks off.

(해석) 그들은 인상을 심어주기 위해 한다. 즉, 게스트를 놀래키길 원한다 - 깜짝 놀라게한다(크게 감동시킨다)

[12] They should just go back saying, ‘I couldn't eat even half of it!’, you know.

(해석) 그들은 다시 돌아가서 말해야 한다. 절반밖에 못먹었어.

[13] The problem is that no matter how extravagant and expensive one buffet is, the next one has to be even more impressive, something Sandeep calls a vicious circle – a difficult situation which has the effect of creating new problems which then make the original situation even worse.

(해석) 문제는 한(one) buffet 가 아무리 사치스럽고 비쌀지라도, 다음 것(one)은 더 인상적이어야 한다. sandeep이 vicious circle 이라고 부르는 것이다. - 원래 상황을 더 안좋게 만드는 새로운 문제를 만들어 내는 효과가 있는 어려운 상황.

1. No matter how + 형용사 + S + V : 아무리 (형용사) 해도, (형용사) 일지라도

2. one ~ , next one : sequential 한 관계에서의 비교를 하기 위해서 사용

3. something 이 관계사 which(that) 처럼 쓰임

4. has the effect of ~ ing : ~ 하는 효과가 있는

[14] It seems the secret to enjoying a buffet is trying a little bit of everything, without stuffing yourself until you can’t move – although in the past, I think, that was exactly the idea.

(해석) buffet 를 즐기는 비밀은 전부를 조금씩 시도해보는 것 같다. 움직일 수 없을 때까지 (자신의) 속을 꽉 채우지 않고 - 비록 과거에 그랬었더라도, 내 생각엔 그게 정확한 아이디어인거 같다.

1. secret to ~ ing : ~하는 비밀

2. try a little bit of everything : 조금씩 전부 시도해보다

3. stuff : 속을 꽉 채우다

4. although in the past: 비록 과거엔 그랬더라도(?)

[15] In fact buffets are thought to have come from Sweden in the Middle Ages.

(해석) 사실 buffet 는 중세 스웨덴에서 유래됐다고 생각되고 있다.

1. 현재 생각되고 있으므로, think 수동태 + 현재시제로 표현

2. have come from : 의미상 '유래' 는 과거부터 쭉 이어져온 것이므로 현재완료로 표현

즉, A are thought to come from B 일 경우, A는 B로부터 온다고 생각된다로 해석됨

Vocabulary

eyes bigger than your belly
(idiom) used when someone has taken more food than they can eat

pile up
gather a large quantity of something into a one place to form a pile

*pile: (포개 쌓아 놓은) 더미

get your money's worth
get good value for the money you have spent

vicious circle
problem or difficult situation which has the effect of creating new problems which then make the original situation even worse

knock your socks off
(idiom) amaze and impress someone

caterer
person or company which provides food and drink for special social occasions

TRANSCRIPT

Neil
Hello. This is 6 Minute English from BBC Learning English. I’m Neil.

Sam
And I’m Sam.

Neil
Have you ever been to an all-you-can-eat buffet, Sam? You know – a meal in a restaurant where you can eat as much food as you like.

Sam
Yes, I went to an Indian buffet once. I didn’t eat all day before the meal, but [1] I only managed to finish three or four plates…well, maybe five!

Neil
It sounds like your eyes were bigger than your belly, or stomach – a phrase describing someone who has taken more food than they can eat. In this programme we’ll be discussing buffets – a feast of many different food dishes where diners are allowed to eat as much as they want – or as much as their stomachs will allow. And, of course, we’ll be learning some new vocabulary as well.

Sam
The popularity of buffets is booming, especially in Middle Eastern and Asian countries where the variety of foods means there’s something for everyone. But feasts are big and boastful - [2] usually too much is cooked, and buffets have been criticised for waste.

Neil
We’ll hear more soon, but first I have a question for you, Sam. [3] The word ‘buffet’ originated from the French name for the table on which food was served, but buffets themselves don’t come from France. So in which country did buffets begin?

a) The United States of America

b) Sweden

c) China

Sam
Well, the US is famous for supersizing food so I’ll guess a) America.

Neil
OK, Sam. We’ll find out the answer later in the programme. John Wood, owner of cooking company Kitchen Cut, knows a lot about buffets – he used to run a one thousand seat breakfast buffet at the five-star Jumeirah Beach Hotel in Dubai. Here [4] John shares his observations on human buffet behaviour with BBC World Service programme, The Food Chain.

John Wood
[5] There are different people that treat buffets in different ways. [6] Some people think this is a great opportunity to try little bits and lots of everything, and we come back as many times as I like. [7] And other people just - whether they don't like getting up and down, which is understandable from their table - just want to pile it high, and people they want to getvalue for money. So, [8] if you're paying $100, $200 a head for a buffet, you're gonna pile it up high and take the most expensive things you can you know, and get your money's worth.

Sam
John says buffet diners want to get their money’s worth – get good value for the money they spend, so they often pile up food on their plate. [9] If you pile something up, you gather a large amount of it into one place to build what’s called a pile.

Neil
But buffets are not just about eating until you explode - they’re also an opportunity to show off to your friends. Weddings are big in India, and usually include a buffet. [10] The richer the people getting married, the bigger the buffet, sometimes inviting as many as five thousand guests. If each guest eats around six dishes, we’re taking about a seriously big buffet!

Sam
Sandeep Sreedharan is a wedding caterer from Goa in South India – he owns a company which provides the food and drink for special social occasions. Here he talks with Ruth Alexander, presenter of BBC World Service, The Food Programme, about organising an Indian wedding buffet:

Sandeep Sreedharan
It's a very vicious circle, I think, right? Everybody wants to overwhelm everybody around you.

Ruth Alexander
OK. That's the aim. [11] They are out to impress - they want to ‘wow’ the guests - knock their socks off.

Sandeep Sreedharan
Knock their socks off. [12] They should just go back saying, ‘I couldn't eat even half of it!’, you know. Some people just come for eating. They don't even worry about who's wedding is it… They know that… ‘Who's the caterer? Ah, these guys are catering. Oh my God, this is gonna be great.

Sam
Wedding buffets are designed to amaze and overwhelm the guests with their huge displays of food. They need to ‘wow’ the guests, or knock their socks off – an idiom meaning to amaze and impress someone.

Neil
[13] The problem is that no matter how extravagant and expensive one buffet is, the next one has to be even more impressive, something Sandeep calls a vicious circle – a difficult situation which has the effect of creating new problems which then make the original situation even worse.

Sam
[14] It seems the secret to enjoying a buffet is trying a little bit of everything, without stuffing yourself until you can’t move – although in the past, I think, that was exactly the idea.

Neil
OK, it’s time to reveal the answer to my question - where did the buffets originally come from?

Sam
I guessed it was from the United States. Was I right?

Neil
That was… the wrong answer, I’m afraid, Sam. In fact buffets are thought to have come from Sweden in the Middle Ages.

Sam
OK, let’s recap the vocabulary we’ve learned, starting with the expression, eyes bigger than your belly, or eyes bigger than your stomach,used when someone has taken more food than they can eat.

Neil
If you pile up your plate,you gather a large quantity of food together into a pile.

Sam
The phrase to get your money’s worth means to get good value for the money you have spent .

Neil
A vicious circle is a problematic situation, having the effect of creating new problems which then make the first situation even worse.

Sam
The idiom to knock your socks off means to wow, amaze or impress someone.

Neil
And finally, a caterer is a person or company which provides food and drink for special social occasions. Once again, our six minutes are up. Bye for now!

이것저것

미국 천연가스 Upstream & Downstream 기업

Upstream 기업

midstream 기업

코엔자임 Q10(코큐텐) 반드시 먹어야 하는 이유

구글 소속 미래학자 '레이 커즈와일'의 영양제

코엔자임 Q10

Ceramic frying fan's pros & cons

그리운 성남 맘스파크 조리원 후기입니다(21년12월)

등센서 있는 아가, 언제까지 안고 재울수 없잖아요(마미품vs라라스배게 리뷰)

Article: ChatGPT Helps Man Launch Business in 24 Hours

ChatGPT Helps Man Launch Business in 24 Hours

Discussion

Further Discussion

~에 무리(부담)가/이 갈거야 영어로 + 자주 쓰는 표현 5개

be hard on (someone/something) : ~ 에 무리(부담)가 /이 갈거야

영어 표현 5개 소개

You gotta start somewhere : 어디서든 시작해봐 (완벽하지 않더라도 시작하는게 중요하다)

There's only one way to find out : 해보는 수밖에 없지, 해보면 알겠지

What's the worst that can(could) happen? (= It's worth trying) : 별일 있겠어? What have we(you) got to lose ? : 잃을게 뭐 있어?

If you must know , ... : 설명해줄 필요도 없지만 굳이 알려주자면

I'll have you know (that) ... : 너가 몰라서 그러는데, ...

변환 생성자(conversion constructor)의 활용

C++ 컴파일러로 C 소스코드를 함께 컴파일하고자 할때 (extern C)

name mangling 이란?

걔 원래 그렇다고?, 나아진거야 예전엔 훨씬 심했어 / ~했던 때 기억나? 영어로

걔가 원래 그렇다고? < You mean he's always like that ?>몇년 된거 같은데, 사실 많이 나아진거야 <It's been a few years now, but it's gotten a lot better actually>예전에는 훨씬 심했어 <It used to be a lot worse >

~ 했던거(때) 기억나? < Remember when ~>

생각이 나다 , 생각이 들다 , 생각해내다 영어로 + <영어식 표현: get to, give a better idea>

정확히 생각은 안나 (정확히 기억나진 않아) < I can't remember exactly >~ 하려고 생각했어 < I figured I should ~ >딱히 생각나는데가 없어 : < I couldn't really think of anywhere >

get to

give someone a better understanding ofgive someone deeper insight intogive someone an idea of

Firmware(펌웨어)와 elf, bin, hex 파일

펌웨어(Firmware)

펌웨어 업데이트

elf, hex, bin 파일

RPC(Remote procedure call) server 란?

RPC 프로토콜

RPC 서버

일반 서버-클라이언트 모델과 차이점

클라이언트

RPC

하이퍼바이저(hypervisor) 와 도커(docker)

하이퍼바이저(hypervisor)

도커(docker)

하이퍼바이저와 도커

static / dynamic library (shared object) 와 링킹(linking)

라이브러리(library)란?

원어민이 자주쓰는 문장 30개

1. Take your time : 여유를 가져, 천천히 해

2. Never mind : 신경 쓰지마, 아무것도 아니야

3. I'll be right back : 금방(짧은 시간) 돌아올게

4. Are you ready to ~ ? : ~ 할 준비 됐어요?

5. I can tell : 보니까 알거 같아 / 보니까 그런거 같아

6. go ahead : 먼저 하세요/ 그렇게 하세요

7. Here you go : 여기요

8. Have a good one : 좋은하루 보내세요

[C++] std::fstream 의 역할과 작동원리

예제: 파일 읽고 쓰 기

예제 : 로그 파일 생성

fstream과 버퍼

fstream 내부 버퍼와 운영체제의 버퍼

seekg

~할 가능성이 높다 / 낮다 영어로

~할 가능성이 높다: There's a good chance that + ~

~할 가능성이 높다/ 낮다 : (not) likely , It's likely that ~

I doubt that ~ : 성격은 좀 다름 . 가능성이 별로없다라고 할 때만 쓰임 (나의 판단)

QNX - HAM, Pulse, Signal

HAM (High availablity manager)

pulse

Signal

버퍼(buffer)와 표준입력 스트림(stream) 그리고 getch 와 getchar

버퍼(Buffer)

버퍼와 사용자 메모리

std::cin

getch

getchar

getch()와 getchar() 차이

const char* 와 string class

const char* : C-style 문자열을 나타내는 포인터

What's the worst that can(could) happen? (= It's worth trying) : 별일 있겠어?
What have we(you) got to lose ? : 잃을게 뭐 있어?

걔가 원래 그렇다고? < You mean he's always like that ?>
몇년 된거 같은데, 사실 많이 나아진거야 <It's been a few years now, but it's gotten a lot better actually>
예전에는 훨씬 심했어 <It used to be a lot worse >

정확히 생각은 안나 (정확히 기억나진 않아) < I can't remember exactly >
~ 하려고 생각했어 < I figured I should ~ >
딱히 생각나는데가 없어 : < I couldn't really think of anywhere >

give someone a better understanding of
give someone deeper insight into
give someone an idea of

4. figure out: 몰랐던 '문제'의 해결책, 방법을 알게 되다. 그 과정,변화를 이야기함."알아냈어"
+ "이해하기 위해 노력하는 것"