프로그래밍 언어 및 기술 [언제나휴일]

2. 3 요구 사항 및 유즈케이스 매핑

언휴 — Sun, 26 Jan 2025 14:31:30 +0900

요구 사항을 파악한 후에 유즈케이스 다이어그램을 작성하였으면 이 둘 간의 매핑 테이블을 만들어 보세요. 이를 통해 어떠한 요구 사항이 어느 유즈케이스에 반영했는지 파악하기 쉽고 반영하지 않은 요구 사항이 있는지 확인하기 쉬워집니다.

하나의 요구 사항을 반영하는 여러 개의 유즈케이스가 있을 수 있고 여러 개의 요구 사항을 반영하는 하나의 유즈케이스가 있을 수 있습니다. 그리고 품질에 관한 요구 사항을 반영하는 특정 유즈케이스가 없을 수도 있습니다.

요구명	관련 Usecase
웹 로봇	WebCollect
분석기	Morphemepares
색인기	MakeInvertedFile
랭커	Ranking
관리	SetInterval, Start, Stop, AddSeedSite
검색	Search
결합성	품질 요구 사항임
재사용성	품질 요구 사항임
시스템화	GetInvertedFile, Ranking,GetPostedUrl, WebCollect, MakeInvertedFile
웹 로봇	WebCollect
분석기	Morphemepares
색인기	MakeInvertedFile

[표 2.5] 요구 사항 및 유즈케이스 매핑

언제나휴일 여행 및 산책

현충사

2. 2 유즈케이스 다이어그램

언휴 — Sat, 25 Jan 2025 10:59:52 +0900

유즈케이스 다이어그램은 시스템에서 구현해야 할 기능을 개괄적으로 보여주기 위해서 수행합니다. 이를 통해 시스템이 처리해야 할 일과 외부에서 수행할 일을 결정하고 어떠한 사용자와 시스템과 상호 작용하는지를 결정합니다.

이를 위해 먼저 시스템과 상호 작용하는 사용자와 외부 시스템을 찾는 작업을 수행합니다. 유즈케이스 다이어그램에서는 시스템과 상호 작용하는 사용자와 외부 시스템을 액터라고 말합니다.

[ 그림 2.1] 액터

그리고 액터가 어떨 때 우리 시스템을 사용하는지 우리 시스템이 언제 액터를 사용하는지를 결정합니다. 그리고 이를 유즈케이스로 나타냅니다.

[ 그림 2.2] Usecase

Usecase 다이어그램은 액터와 Usecase, 관계를 표현합니다.

2.2.1 액터 개요

액터는 시스템과 상호 작용하는 사용자와 외부 시스템을 말합니다.

EH WSE를 사용하는 액터에는 최종 사용자(End User)와 관리자(Manager)가 있습니다. 그리고 외부 시스템에는 DBMS가 있습니다.

[ 그림 2.3] 액터 개요

번호	액터 이름	설명
1	End User	검색 서비스를 사용하는 사용자
2	Manager	검색 서비스 테스트 및 웹 수집 로봇 설정 및 모니텅링을 수행하는 관리자
3	DBMS	솔루션의 DB를 관리하는 시스템(MS SQL)

[표 2.2] 액터

2.2.2 유즈케이스 다이어그램

먼저 최종 사용자와 상호 작용에 관한 유즈케이스 다이어그램을 작성합시다. 최종 사용자는 검색할 때만 EH WSE와 상호 작용합니다. 검색 요청하면 내부 시스템에서는 검색 질의를 형태소로 분리하는 작업을 수행합니다(MorphemeParse). 그리고 색인 데이터에서 질의 요소를 포함하는 웹 페이지 정보를 얻어옵니다(GetInvertedFile). 검색 정보를 순위화하고(Ranking) 수집한 페이지의 정보를 보여줍니다(GetPostedUrl).

[ 그림 2.4] End User와 상호 작용 usecase 다이어그램

번호	유즈케이스 이름	설명
1	Search	검색
2	MorphemeParser	형태소 분석
3	GetInvertedFile	역 파일 생성
4	Ranking	순위 부여
5	GetPostedUrl	수집한 결과 페이지 얻어오기

[표 2.3] End User와 상호 작용하는 Usecase

관리자는 최종 사용자처럼 검색할 수 있습니다. 그리고 이 외에도 Seed 사이트 주소를 추가(AddSeedSite)하거나 수집 주기를 설정(SetInterval), 웹 로봇이 수집하는 것을 가동시키거나(Start) 멈추게 하고(Stop) 수집해야 할 사이트를 확인(NeedGetUrls), 수집한 색인 데이터를 확인(GetMorphemes)합니다.

관리자가 웹 수집을 가동하면 주기적으로 웹 페이지를 수집(WebCollect)합니다. 그리고 수집한 웹 페이지의 내용을 분석(MorphemeParse)하고 색인 데이터를 만드는 작업을 수행합니다(MakeInvertedFile).

[ 그림 2.5] Manager와 상호 작용 usecase 다이어그램

참고로 특정 Usecase를 수행하면서 반드시 수행해야 하는 Usecase는 <<include>> 스테레오 관계로 표시하며 선택적으로 수행할 때는 <<extend>> 스테레오 관계로 표시합니다. <<include>> 스테레오는 반드시 수행해야 하는 Usecase로 화살표 방향을 표시하며 <<extend>> 스테레오는 선택적으로 수행하는 Usecase에서 시작하는 방향으로 표시합니다.

[표 2.4]는 Usecase별로 어떠한 역할을 수행하는지와 관련 액터 및 상호 작용 방향을 표로 정리한 것입니다.

이와 같이 작업한 내용을 파악하기 쉽게 문서로 작성해 놓으면 효과적으로 관리할 수 있습니다. 프로젝트의 종류와 목적에 따라 어느 수준으로 회의와 문서화, 개발 방법론 적용이 다를 수 있는데 중요한 것은 모든 작업이 개발에 득이 되는 수준으로 행해야 한다는 것입니다. 그 어떠한 작업도 많이 하면 독이 되고 부족하면 품질 수준 저하 및 전체 개발 비용이 많아질 수 있습니다. 어느 수준으로 적용해야 최소 비용으로 최대 품질의 서비스를 제공할 수 있을지 고민하고 상황에 맞는 개발 방법론을 판단할 수 있는 능력을 키우셔야 합니다.

Usecase 명	설명	관련 액터 및 방향
Search	검색 요청	EndUser(→), Manager(→)
GetInvertedFile	역 파일 요청	(→)DBMS
Ranking	검색 결과 순위 부여	(→)DBMS
GetPostedUrl	수집한 웹 페이지 요청	(→)DBMS
AddSeedSite	Seed 사이트 추가	Manager(→)
SetInterval	수집 주기 설정	Manager(→)
Start	웹 수집기 가동	Manager(→)
Stop	웹 수집기 멈춤	Manager(→)
NeetGetUrls	수집 후보 Url들을 요청	Manager(→)
GetMorphemes	모든 형태소 요청	Manager(→)
WebCollect	웹 수집	(→)DBMS
MorpemeParse	형태소 분석
MakeInvertedFile	역 파일 생성	(→)DBMS

[표 2.4] Usecase 리스트

언제나휴일 여행 및 산책

에버랜드 판다월드, 엄마 아이바오와 쌍둥이 루이와 후이

2. 요구 분석 및 정의 2.1 요구 리스트

언휴 — Sat, 25 Jan 2025 10:55:19 +0900

요구 분석 및 정의 단계에서는 시스템에서 제공해야 할 비지니스와 이해관계자의 요구 사항을 정확히 이해하는 작업이 필요합니다.

이를 위해 이해관계자의 요구 사항을 수집하고 이해해야 합니다. 그리고 수집한 요구사항을 바탕으로 시스템에서 제공해야 할 기능을 개괄적으로 파악하고 결정해야 합니다.

이 책에서는 어떠한 이해관계자가 있는지에 관한 조사와 이를 통해 요구 사항을 수집하는 부분은 간단히 요구 리스트를 보여주는 것으로 끝낼 것입니다.

대신 요구 리스트를 바탕으로 시스템에서 제공해야 할 기능을 파악하고 결정하기 위해서 Usecase 다이어그램을 작성하고 요구 사항과 Usecase 매핑 테이블을 작성하기로 할게요.

2.1 요구리스트

요구명	설명	구분
웹 로봇	웹 페이지를 수집할 수 있어야 합니다.	기능
분석기	수집된 웹 페이지를 분석할 수 있어야 합니다.	기능
색인기	분석된 요소별로 색인을 만들 수 있어야 합니다.	기능
랭커	질의에 해당하는 웹 페이지를 TF-IDF 방식에 의거하여 랭킹합니다.	기능
관리	웹 검색 엔진을 설정 및 구동을 제어할 수 있어야 합니다.	기능
검색	웹 검색을 요청할 수 있고 검색된 결과를 순위화 하여 보여주어야 합니다.	기능
결합성	각 엔진은 분리해야 합니다.	품질
재사용성	공통적인 형식은 라이브러리화 하여야 합니다.	품질
시스템화	각 엔진에 의한 결과들은 DBMS에 의해 관리해야 합니다.	기능/ 품질

[표 2.1] 요구 리스트

언제나휴일 여행 및 산책

현충사

1. 7 .NET 리모팅

언휴 — Wed, 22 Jan 2025 18:28:40 +0900

.NET 리모팅 기술은 서버 측에 있는 개체를 클라이언트 측에서 마치 자신에게 있는 개체를 사용하는 것처럼 사용할 수 있게 서비스를 하는 기술입니다.

.NET 리모팅 서비스를 위해서는 서비스를 제공하는 서버와 서비스를 제공받는 클라이언트가 필요하며 서버 측에서 클라이언트에 제공하는 개체를 정의한 클래스 라이브러리가 필요합니다.

서버 측에서 클라이언트에 제공하는 개체는 MashalByReference에서 파생한 개체로 원격 개체라고 말합니다.

서버 측에서는 채널을 등록하여 원격 개체를 사용할 수 있게 등록합니다. 클라이언트 측에서는 서버 측 채널에 접근하여 원격 개체를 참조하여 사용하는데 클라이언트 측에서 원격 개체를 참조하여 사용할 수 있는 개체를 Proxy 개체라 부릅니다.

클라이언트 측에서 Proxy 개체를 통해 메서드를 호출하면 포멧터를 통해 메서드 이름과 인자 등을 Masharing하여 서버 측에 전달하면 서버 측의 Stub에서 이를 수신하여 실제 개체인 원격 개체를 제어합니다. 그리고 결과를 같은 방법으로 서버 측의 Stub에서 클라이언트 측의 Proxy 개체에게 전송하고 Proxy개체는 수신한 정보로 결과를 반환하는 원리입니다.

[그림] .NET 리모팅 구조

간단하게 .NET 리모팅 서비스를 구축하고 이를 사용하는 클라이언트를 구현해 봅시다.

여기에서 실습할 내용은 0~9 사이의 숫자를 입력받으면 이를 "one"~"nine"으로 변환하는 서비스를 제공하는 것으로 할게요.

1.7.1 공통 라이브러리 제작

먼저 클래스 라이브러리 형태의 프로젝트를 생성합니다. 그리고 기본으로 제공하는 소스 파일명을 NumToEng.cs로 변경하세요.

.NET 리모팅으로 클라이언트에서 참조하여 사용하기 위해서는 MashalByRefObject를 기반으로 파생 클래스를 정의해야 합니다.

public class NumToEng:MarshalByRefObject
{

}

변환에서 반환할 문자열을 담을 배열을 선언 및 초기화합시다.

string[] warr = new string[] {  "zero","one","two","three","four","five","six","seven","eight","nine"  };

그리고 0~9 사이의 정수를 입력받아 영어로 변환한 문자열을 반환하는 메서드를 추가합시다. 동작 흐름을 파악하기 위해 의도적으로 콘솔에 출력하는 구문을 넣었습니다.

public string Convert(int num)
{
    Console.WriteLine("NumToEng 개체의 Convert 메서드 :{0} 받음", num);
    if ((num >= 0) && (num <= 9))
    {
        return warr[num];
    }
    return "none";
}

▶ NumToEng.cs

using System;
 
namespace NumToEngLib
{
    /// <summary>
    /// 변환기(0~9 사이의 정수를 영어로)
    /// </summary>
    public class NumToEng:MarshalByRefObject
    {
        string[] warr = new string[]
        {
            "zero","one","two","three","four","five","six","seven","eight","nine"
        };
        /// <summary>
        /// 변환 메서드
        /// </summary>
        /// <param name="num">0~9 사이의 정수</param>
        /// <returns>변환한 문자열</returns>
        public string Convert(int num)
        {
            Console.WriteLine("NumToEng 개체의 Convert 메서드 :{0} 받음", num);
            if ((num >= 0) && (num <= 9))
            {
                return warr[num];
            }
            return "none";
        }
    }
}

1.7.2 서버 예광탄 제작

그리고 서버를 구축하기 위해 콘솔 응용 프로그램 형태의 서버 예광탄 프로젝트를 추가하세요. 여기에서는 .NET 리모팅을 소개하는 것을 목적으로 콘솔 응용 프로그램 형태로 제작할게요.

.NET 리모팅 서버를 구축하려면 System.Runtime.Remoting 어셈블리를 참조 추가해야 합니다. 그리고 앞에서 만든 NumToEngLib를 참조 추가하세요.

서버 측에서는 클라이언트에서 연결할 수 있는 채널을 등록합니다. TCP 채널과 HTTP 채널을 사용할 수 있는데 여기에서는 방화벽에 친숙한 HTTP 채널을 생성하여 등록할게요.

HttpChannel hc = new HttpChannel(16000);
ChannelServices.RegisterChannel(hc, false);

그리고 클라이언트에서 원격으로 참조할 수 있는 개체 형식을 등록합니다. 등록할 수 있는 서비스 종류는 여러 가지가 있는데 여기에서는 서버 측 활성화 개체로 단일개체 모드로 등록할게요.

RemotingConfiguration.RegisterWellKnownServiceType(
           typeof(NumToEng),
            "MySvc",
            WellKnownObjectMode.Singleton
            );

프로세스가 키를 누를 때까지 종료하지 않고 대기할 수 있게 합시다.

Console.ReadKey();

▶ Program.cs

using System;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting;
using NumToEngLib;
 
namespace 서버_예광탄
{
    class Program
    {
        static void Main(string[] args)
        {
            HttpChannel hc = new HttpChannel(16000);
            ChannelServices.RegisterChannel(hc, false);
 
            RemotingConfiguration.RegisterWellKnownServiceType(
                typeof(NumToEng),
                "MySvc",
                WellKnownObjectMode.Singleton
                ); 
 
            Console.ReadKey();
        }
    }
}

1.7.3 클라이언트 제작

.NET 리모팅 서비스를 사용하는 클라이언트를 만듭시다. 클라이언트는 Windows Forms 형태의 응용 프로그램을 작성합시다.

[그림] 클라이언트 메인 폼 컨트롤 배치

번호	컨트롤 이름	컨트롤 유형	설명
1	nud	NumericUpDown	정수 선택
2	btn_convert	Button	변환 명령
3	lb_digit	Label	정수를 변환한 문자열

[표 1.5] 클라이언트 메인 폼의 자식 컨트롤

.NET 리모팅 서비스를 사용하는 클라이언트도 System.Runtime.Remoting 어셈블리와 공용 라이브러리인 NumToEngLib 어셈블리를 참조 추가해야 합니다.

메인 폼의 Load 이벤트 핸들러를 추가하여 채널 생성 및 등록합니다.

private void MainForm_Load(object sender, EventArgs e)
{
    HttpChannel hc = new HttpChannel();
    ChannelServices.RegisterChannel(hc, false);
}

변환 버튼의 Click 이벤트 핸들러를 추가합니다.

private void btn_convert_Click(object sender, EventArgs e)

이벤트 핸들러에서는 원격 서버로부터 원격 개체를 참조합니다. 이 때 Activator 클래스의 정적 메서드 GetObject를 이용합니다. 클라이언트 측에서 참조한 개체는 실제 개체가 아닌 원격 개체의 Proxy 개체입니다.

NumToEng nte = Activator.GetObject(
        typeof(NumToEng),
        "http://[서버 IP]:16000/MySvc")
        as NumToEng;

그리고 원격 개체를 참조한 nte의 Convert 메서드를 호출하여 결과를 레이블의 Text 속성을 지정합니다.

lb_digit.Text = nte.Convert((int)nud.Value);

이제 빌드한 후에 서버를 실행하고 클라이언트를 실행하여 테스트 하면 다음과 같이 동작함을 알 수 있습니다.

[그림] 시연 화면

시연 화면을 보면 알 수 있듯이 서버 측의 원격 개체의 Convert 메서드가 동작함을 알 수 있습니다.

▶ MainForm.cs

using System;
using System.Windows.Forms;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels;
using NumToEngLib;
 
namespace 클라이언트_예광탄
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }
        private void btn_convert_Click(object sender, EventArgs e)
        {
            NumToEng nte = Activator.GetObject(
                typeof(NumToEng),
                "http:// [서버 IP]:16000/MySvc")
                as NumToEng;
            lb_digit.Text = nte.Convert((int)nud.Value);
        } 
        private void MainForm_Load(object sender, EventArgs e)
        {
            HttpChannel hc = new HttpChannel();
            ChannelServices.RegisterChannel(hc, false);
        }
    }
}

언제나휴일 여행 및 산책

에버랜드 판다월드, 러바우버랜드 판다월드, 러바우 먹방

1. 6 Windows Form

언휴 — Mon, 20 Jan 2025 13:47:27 +0900

이번에는 간단하게 Windows Form 응용 프로그램을 만들기 위해 필요한 기술을 알아봅시다. 먼저 윈도우즈 응용 프로그램을 만들기 위해 Windows Forms 응용 프로그램 템플릿을 선택합니다.

[그림] Windows Forms 응용 프로젝트 생성

Windows Forms 응용 프로젝트를 생성하면 기본적으로 진입점이 있는 Program.cs 파일과 MainForm에 관한 두 개의 소스 파일로 Form1.cs와 Form1.Designer.cs이 만들어집니다. Program.cs 파일에는 Form1 개체를 생성하여 닫힐 때까지 수행할 수 있는 코드 등이 자동으로 만들어진 상태입니다. 특이 사항이 없으면 Windows Forms 응용 프로그램을 제작하면서 이 부분을 수정할 필요는 없습니다.

그리고 Form1.cs는 개발자가 작성할 부분이며 Form1.Designer.cs는 통합 개발 환경의 디자인 창에서 자식 컨트롤 배치나 속성 지정 및 이벤트 핸들러를 추가한 부분의 코드를 마법사에 의해 작성해 주는 부분입니다. 마찬가지로 개발자는 Form1.Designer.cs 부분을 수정할 필요는 거의 없습니다.

[그림] 기본으로 만들어지는 파일들

▶ Program.cs의 Program 클래스의 코드 내용

static class Program
{
    /// <summary>
    /// 해당 응용 프로그램의 주 진입점입니다.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }
}

Windows Form 프로젝트를 생성할 때 만들어진 메인 폼의 이름이 Form1인데 이를 자신이 원하는 이름으로 변경하세요.

[그림 1] Form1 이름 바꾸기

[ 그림 ]Form1 이름 바꾸기 과정에 나오는 메시지 창

위처럼 작업하면 Form1.cs 파일 이름과 Form1.Designer.cs 파일 이름이 자동으로 바뀌고 Form1 클래스 이름도 원하는 이름으로 바뀌는 것을 알 수 있습니다. 또한 Program.cs 파일에서 new Form1() 호출 부분도 바꾼 이름으로 자동으로 바꿔줍니다. 이 책에서는 자동으로 만들어진 Form1 이름을 언제나 MainForm으로 변경하고 있습니다.

그리고 속성 창을 이용하면 디자인 창의 다양한 컨트롤의 속성을 효과적으로 설정하거나 확인할 수 있습니다.

[그림 1] 속성 창 사용하기

속성 창에서는 컨트롤이나 폼의 속성을 설정 및 확인할 수 있고 이벤트 핸들러를 설정 및 확인할 수 있습니다. 속성 창의 툴 바에는 항목 별로 정렬하거나 알파벳 순으로 정렬할 수 있는 버튼을 제공합니다. 그리고 뒤에 나오는 두 개의 버튼은 속성과 이벤트 핸들러를 의미합니다.

[그림] 속성 창의 툴바

그리고 도구 상자를 이용하여 자식 컨트롤을 쉽게 배치할 수 있습니다.

[그림 1] 도구 상자를 이용한 컨트롤 배치

물론 배치한 컨트롤의 속성이나 이벤트 핸들러 등은 속성 창을 통해 쉽게 설정 및 확인할 수 있습니다.

1.6.1 간단한 Windows Forms 응용 만들기

이제 간단하게 아이디와 이름을 입력받아 리스트 상자의 항목에 아이디를 추가하고 이를 항목을 선택하면 선택한 항목의 이름을 레이블 컨트롤의 속성을 이용하여 변화하는 간단한 프로그램을 작성해 봅시다. 먼저 MainForm에 자식 컨트롤을 배치합니다.

[그림 1.21] MainForm에 자식 컨트롤 배치

번호	컨트롤 이름	컨트롤 유형	설명
1	lb_id	Label	Text 속성: 아이디:
2	tbox_id	TextBox
3	lb_name	Label	Text 속성: 이름:
4	tbox_name	TextBox
5	btn_add	Button
6	lbox_member	ListBox
7	lb_name2	Label	Text 속성: [홍길동]

[표 1.1] MainForm의 자식 컨트롤

이 프로그램에서는 회원 데이터를 관리할 것입니다. 이를 위해 Member 클래스를 추가하기로 합시다.

▶ Member.cs

namespace First_Windows_Forms
{
    public class Member
    {
        public string Id
        {
            get;
            private set;
        }
        public string Name
        {
            get;
            private set;
        }
        public Member(string id, string name)
        {
            Id = id;
            Name = name;
        }
        public override string ToString()
        {
            return Id;
        }
    }
}

그리고 회원 관리자를 클래스로 정의합시다. Windows Forms 응용 프로그램을 작성할 때 관리할 데이터와 Forms 사이의 관계를 느슨하게 작성하기 위함입니다. GUI 부분은 요구 사항이 자주 바꾸는 부분이므로 사용자와 상호 작용하는 부분을 변경하더라도 주요 코드는 변경하지 않게 하려면 데이터를 관리하는 부분을 별도의 클래스로 정의하세요.

특히 프로그램의 전체 데이터를 관리하는 개체는 단일 개체로 표현하여 여러 폼에서 사용하더라도 같은 데이터를 사용할 수 있게 해 주는 것은 좋은 코딩 습관이라 할 수 있습니다.

public class MemberManager
{
    static MemberManager mm = new MemberManager();
    public static MemberManager MM
    {
        get
        {
            return mm;
        }
    }
    private MemberManager()
    {
    }
}

현재까지의 시나리오에서는 회원을 추가하는 부분과 특정 아이디의 회원 이름을 검색하는 부분만 필요합니다. 이 부분을 수행할 수 있게 MemberManager 클래스를 정의합시다. 먼저 멤버 필드로 회원 아이디를 키로 Member 개체를 값으로 하는 사전 개체를 선언합시다.

Dictionary<string, Member> mdic = new Dictionary<string, Member>();

회원 아이디와 이름을 입력 인자로 받아 회원 데이터를 추가하는 메서드를 제공합시다. 만약 이미 존재하는 아이디일 때는 거짓을 반환하고 그렇지 않을 때 회원 개체를 생성하여 보관한 후에 참을 반환합니다.

public bool AddMember(string id, string name)
{
    if (mdic.ContainsKey(id))
    {
        return false;
    }
    mdic[id] = new Member(id, name);
    return true;
}

그리고 회원 아이디로 회원 이름을 검색하는 메서드를 제공합시다. 입력받은 회원 ID가 존재하면 회원의 이름을 반환하고 그렇지 않으면 string.Empty를 반환합시다.

public string FindMemberName(string id)
{
    if (mdic.ContainsKey(id))
    {
        return mdic[id].Name;
    }
    return string.Empty;
}

▶ MemberManager.cs

using System.Collections.Generic;
 
namespace First_Windows_Forms
{
    public class MemberManager
    {
        Dictionary<string, Member> mdic = new Dictionary<string, Member>();
        static MemberManager mm = new MemberManager();

        public static MemberManager MM
        {
            get
            {
                return mm;
            }
        }

        private MemberManager()
        {
        }

        public bool AddMember(string id, string name)
        {
            if (mdic.ContainsKey(id))
            {
                return false;
            }
            mdic[id] = new Member(id, name);
            return true;
        }
        public string FindMemberName(string id)
        {
            if (mdic.ContainsKey(id))
            {
                return mdic[id].Name;
            }
            return string.Empty;
        }
    }
}

MainForm에서는 회원 관리자의 단일 개체를 사용하여 사용자의 요청에 맞게 회원 데이터를 추가하거나 검색합니다. 쉽게 접근할 수 있게 MainForm.cs에 속성을 추가합시다.

private MemberManager MM
{
    get
    {
        return MemberManager.MM;
    }
}

속성 창의 이벤트 툴 버튼을 선택하여 Click 이벤트 핸들러를 추가하세요. 디자인 창의 버튼을 더블 클릭하여도 버튼의 Click 이벤트 핸들러를 자동으로 추가해 줍니다. 디자인 창에서 컨트롤을 더블 클릭하면 개발자가 기본으로 처리할 것이라 생각하는 이벤트 핸들러를 자동으로 추가해 줍니다.

private void btn_add_Click(object sender, EventArgs e)

btn_add의 클릭 이벤트 핸들러에서는 두 개의 TextBox에 입력한 정보를 얻어와서 회원 관리자 개체의 AddMember 메서드를 이용하여 추가 요청합니다. 만약 반환 값이 거짓이면 추가 실패 메시지 창을 보여주고 참이면 리스트 상자의 항목에 아이디를 추가합니다.

string id = string.Empty;
string name = string.Empty;
id = tbox_id.Text;
name = tbox_name.Text;
if (MM.AddMember(id, name) == false)
{
    MessageBox.Show("추가 실패");
}
else
{
    lbox_member.Items.Add(id);
}

이번에는 속성 창을 이용하여 lbox_member 컨트롤의 선택 변경 이벤트 핸들러를 추가합니다.

private void lbox_member_SelectedIndexChanged(object sender, EventArgs e)

선택한 항목의 인덱스가 -1이면 선택 항목이 없는 것이므로 메서드를 종료합니다.

if (lbox_member.SelectedIndex == -1)
{
    return;
}

선택 항목을 string 형식으로 참조한 후 회원 관리자 개체를 이용하여 이름을 찾은 후에 이름을 보여줄 Label의 Text 속성을 설정합니다.

string id = lbox_member.SelectedItem as string;
lb_name2.Text = MM.FindMemberName(id);

▶ MainForm.cs

using System;
using System.Windows.Forms;
 
namespace First_Windows_Forms
{ 
    public partial class MainForm : Form
    {

        private MemberManager MM
        {
            get
            {
                return MemberManager.MM;
            }
        }

        public MainForm()
        {
            InitializeComponent();
        } 

        private void btn_add_Click(object sender, EventArgs e)
        {
            string id = string.Empty;
            string name = string.Empty;

            id = tbox_id.Text;
            name = tbox_name.Text;


            if (MM.AddMember(id, name) == false)
            {
                MessageBox.Show("추가 실패");
            }
            else
            {
                lbox_member.Items.Add(id);
            }
        } 

        private void lbox_member_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (lbox_member.SelectedIndex == -1)
            {
                return;
            }
            string id = lbox_member.SelectedItem as string;
            lb_name2.Text = MM.FindMemberName(id);
        }
    }
}

1.6.2 사용자 정의 컨트롤 만들기

이번에는 사용자 정의 컨트롤을 만들고 이를 사용하는 Windows Forms 응용 프로그램을 만들어 봅시다.

실습은 도서 관리자 응용을 만드는 것으로 할게요. 도서 관리자 응용은 Windows Forms 응용 프로그램으로 사용자 정의 컨트롤인 BookControlLib와 BookLib 클래스 라이브러리를 참조합니다. 그리고 BookControlLib는 BookLib 클래스 라이브러리를 참조할 것입니다.

[그림] 도서 관리자 컴포넌트 다이어그램

먼저 클래스 라이브러를 생성하여 디폴트로 제공하는 소스 파일명을 Book.cs로 변경하세요.

Book 클래스는 도서 제목, ISBN, 저자, 출판사, 설명을 멤버 속성으로 캡슐화하는 아주 작은 클래스입니다. 이에 관한 설명은 별도로 하지 않겠습니다.

▶ Book.cs

namespace BookLib
{
    /// <summary>
    /// 도서 클래스
    /// </summary>
    public class Book
    {
        static Book empty = new Book(string.Empty,string.Empty,
                                                 string.Empty,string.Empty,string.Empty);
        /// <summary>
        /// 빈 도서 정적 개체 - 가져오기
        /// </summary>
        public static Book Empty
        {
            get
            {
                return empty;
            }
        }
        /// <summary>
        /// ISBN - 가져오기
        /// </summary>
        public string ISBN
        {
            get;
            private set;
        }
        /// <summary>
        /// 제목 - 가져오기
        /// </summary>
        public string Title
        {
            get;
            private set;
        }
        /// <summary>
        /// 저자 - 가져오기
        /// </summary>
        public string Author
        {
            get;
            private set;
        }
        /// <summary>
        /// 설명 - 가져오기
        /// </summary>
        public string Description
        {
            get;
            private set;
        }
        /// <summary>
        /// 출판사 - 가져오기
        /// </summary>
        public string Publisher
        {
            get;
            private set;
        }


        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="title">제목</param>
        /// <param name="isbn">ISBN</param>
        /// <param name="author">저자</param>
        /// <param name="publisher">출판사</param>
        /// <param name="description">설명</param>        
        public Book(string title,string isbn,string author,string publisher,
                        string description)
        {
            Title = title;
            ISBN = isbn;
            Author = author;
            Description = description;
            Publisher = publisher;
        }
        /// <summary>
        /// ToString 재정의 - 타이틀
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return Title;
        }
    }
}

이제 Windows Forms 컨트롤 라이브러리 형태의 프로젝트를 추가하여 BookControlLib를 만듭시다. 기본으로 제공하는 컨트롤 이름을 BookControl로 변경하세요. 그리고 도서 정보를 시각화하기 위해 자식 컨트롤을 배치합시다.

[그림] BookControl 자식 컨트롤 배치

번호	컨트롤 이름	컨트롤 유형	설명
1	lb_title_info	Label	정보 표시
2	lb_title	Label	도서 제목
3	lb_isbn_info	Label	정보 표시
4	lb_isbn	Label	ISBN
5	lb_author_info	Label	정보 표시
6	lb_author	Label	저자명
7	lb_publisher_info	Label	정보 표시
8	lb_publisher	Label	출판사
9	tbox_description	TextBox	상세 설명, Multiline:True, ReadOnly:True

[표 1.2] BookControl의 자식 컨트롤

그리고 BookLib를 참조 추가합니다.

BookControl에 도서 개체 정보를 변경할 때 이 사실을 필요로 하는 곳을 위해 이벤트 인자 형식과 대리자를 정의합시다.

▶ BookEventArgs.cs

using System;
using BookLib;
 
namespace BookControlLib
{
    /// <summary>
    /// 도서 이벤트 대리자
    /// </summary>
    /// <param name="sender">보낸 이</param>
    /// <param name="e">이벤트 처리에 필요한 인자</param>
    public delegate void BookEventHandler(object sender, BookEventArgs e);
    /// <summary>
    /// 도서 이벤트 인자 클래스
    /// </summary>
    public class BookEventArgs:EventArgs
    {
        /// <summary>
        /// 도서 개체 - 가져오기
        /// </summary>
        public Book Book
        {
            get;
            private set;
        }

        /// <summary>
        /// 도서명 - 가져오기
        /// </summary>
        public string Title
        {
            get
            {
                return Book.Title;
            }
            
        }
        /// <summary>
        /// 저자 - 가져오기
        /// </summary>
        public string Author
        {
            get
            {
                return Book.Author;
            }
        }
        /// <summary>
        /// 출판사 - 가져오기
        /// </summary>
        public string Publisher
        {
            get
            {
                return Book.Publisher;
            }
        }
        /// <summary>
        /// 설명 - 가져오기
        /// </summary>
        public string Description
        {
            get
            {
                return Book.Description;
            }
        }
        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="book">도서 개체</param>
        public BookEventArgs(Book book)
        {
            Book = book;
        }
        /// <summary>
        /// ToString 재정의
        /// </summary>
        /// <returns>도서명</returns>
        public override string ToString()
        {
            return Book.Title;
        }
    }
}

BookControl에는 도서 개체를 멤버 필드와 도서 개체 변경에 관한 이벤트를 멤버로 캡슐화합니다.

public event BookEventHandler ChangedBook = null;
Book book = Book.Empty;

그리고 도서 개체를 가져오기 및 설정하기 속성을 제공합니다. set 블록에서는 도서 변경한 사실을 통보하고 자식 컨트롤의 속성을 변경합니다.

public Book Book
{
    get
    {
        return book;
    }
    set
    {
        if (value == null)
        {
            book = Book.Empty;
        }
        else
        {
            book = value;
        }
        if (ChangedBook != null)
        {
            ChangedBook(this, new BookEventArgs(Book));
        }
        ChangeControlProperty();
     }
}

자식 속성을 변경하는 메서드에서는 각 속성이 string.Empty일 때 디폴트 값으로 설정하고 그 외에는 도서 개체의 속성을 이용하여 설정합니다.

private void ChangeControlProperty()
{
    if (book.Title == string.Empty)
    {
        lb_title.Text = "[제목]";
    }
    else
    {
        lb_title.Text = book.Title;
    }
    if (book.ISBN == string.Empty)
    {
        lb_isbn.Text = "[ISBN]";
    }
    else
    {
        lb_isbn.Text = book.ISBN;
    }
    ...중략...
    tbox_description.Text = book.Description;
}

▶ BookControlLib.cs

using System.Windows.Forms;
using BookLib;
 
namespace BookControlLib
{
    /// <summary>
    /// 도서 컨트롤
    /// </summary>
    public partial class BookControl : UserControl
    {
        /// <summary>
        /// 도서 개체 변경 이벤트
        /// </summary>
        public event BookEventHandler ChangedBook = null;
        Book book = Book.Empty;
        /// <summary>
        /// 도서 개체 - 가져오기, 설정하기
        /// </summary>
        public Book Book
        {
            get
            {
                return book;
            }
            set
            {
                if (value == null)
                {
                    book = Book.Empty;
                }
                else
                {
                    book = value;
                }

                if (ChangedBook != null)
                {
                    ChangedBook(this, new BookEventArgs(Book));
                }

                ChangeControlProperty();
            }
        }

        /// <summary>
        /// 생성자
        /// </summary>
        public BookControl()
        {
            InitializeComponent();
        }
        private void ChangeControlProperty()
        {
            if (book.Title == string.Empty)
            {
                lb_title.Text = "[제목]";
            }
            else
            {
                lb_title.Text = book.Title;
            }
            if (book.ISBN == string.Empty)
            {
                lb_isbn.Text = "[ISBN]";
            }
            else
            {
                lb_isbn.Text = book.ISBN;
            }
            if (book.Author == string.Empty)
            {
                lb_author.Text = "[저자]";
            }
            else
            {
                lb_author.Text = book.Author;
            }
            if (book.Publisher == string.Empty)
            {
                lb_publisher.Text = "[출판사]";
            }
            else
            {
                lb_publisher.Text = book.Publisher;
            }
            tbox_description.Text = book.Description;
        }
    }
}

이제 Windows Forms 응용 프로그램 형태의 도서 관리자 프로젝트를 추가합시다. 그리고 BookControlLib를 참조 추가합니다.

도서 관리자 응용에는 MainForm과 AddForm이 있고 데이터를 관리하는 BookManager 클래스를 정의할 것입니다. 먼저 디폴트로 제공하는 Form1을 MainForm으로 변경하신 후에 AddForm을 추가하세요. 그리고 BookManager 클래스를 추가합니다.

[그림 ] MainForm의 자식 컨트롤 배치

번호	컨트롤 이름	컨트롤 유형	설명
1	btn_add	Button	도서 추가 폼 띄우기 버튼
2	lbox_book	ListBox	도서 목록
3	bc	BookControl	도서 정보

[표 1.3] MainForm의 자식 컨트롤

[그림] AddForm의 자식 컨트롤 배치

번호	컨트롤 이름	컨트롤 유형	설명
1	lb_title_info	Label	정보 표시
2	tbox_title	TextBox	도서명 입력 창
3	lb_isbn_info	Label	정보 표시
4	tbox_isbn	TextBox	ISBN 입력 창
5	lb_author_info	Lable	정보 표시
6	tbox_author	TextBox	저자명 입력 창
7	lb_publisher_info	Label	정보 표시
8	tbox_publisher	TextBox	출판사 입력 창
9	lb_description_info	Label	정보 표시
10	tbox_description	TextBox	설명 입력 창
11	bnt_add	Button	추가 버튼
12	bnt_cancel	Button	취소 버튼

[표 1.4] AddForm의 자식 컨트롤

먼저 BookManager 클래스를 구현합시다.

BookManager 개체는 단일 개체로 정의합시다.

static BookManager bm = new BookManager();
internal static BookManager BM
{
    get
    {
        return bm;
    }
}
private BookManager()
{
}

BookManager에는 도서를 추가하였을 때 이를 알고자 하는 곳에 이 사실을 알려주기 위한 이벤트를 멤버로 캡슐화합니다.

internal event BookEventHandler AddedBook = null;

그리고 ISBN을 키로하고 Book 개체를 값으로 하는 사전 개체를 두어 도서 개체를 관리합시다.

Dictionary<string, Book> bdic = new Dictionary<string, Book>();

도서를 추가하는 메서드를 제공합시다.

internal bool AddBook(string title, string isbn, string author, string publisher,
                              string description)

만약 입력 인자로 받은 isbn이 이미 있으면 거짓을 반환합니다.

if (bdic.ContainsKey(isbn))
{
    return false;
}

입력 인자로 받은 isbn이 없으면 Book 개체를 생성하여 사전 개체에 등록합니다.

bdic[isbn] = new Book(title, isbn, author, publisher, description);

그리고 도서 개체 추가 이벤트 멤버가 null이 아니면 도서를 추가한 사실을 구독하기를 원하는 개체가 있는 것이므로 이벤트 핸들러를 수행합니다.

if (AddedBook != null)
{
    AddedBook(this, new BookEventArgs(bdic[isbn]));
}

그리고 참을 반환합니다.

return true;

▶ BookManager.cs

using System.Collections.Generic;
using BookControlLib;
using BookLib;
 
namespace 도서관리자
{
    class BookManager
    {
        internal event BookEventHandler AddedBook = null;
        Dictionary<string, Book> bdic = new Dictionary<string, Book>(); 
        static BookManager bm = new BookManager();
        internal static BookManager BM
        {
            get
            {
                return bm;
            }
        }
        private BookManager()
        { 
        }
 
        internal bool AddBook(string title, string isbn, string author,
                                      string publisher, string description)
        {
            if (bdic.ContainsKey(isbn))
            {
                return false;
            }
            bdic[isbn] = new Book(title, isbn, author, publisher, description);
            if (AddedBook != null)
            {
                AddedBook(this, new BookEventArgs(bdic[isbn]));
            }
            return true;
        }
    }
}

MainForm에서는 BookManger 개체를 자주 사용할 수 있으므로 쉽게 참조할 수 있게 속성을 정의합니다.

BookManager BM
{
    get
    {
        return BookManager.BM;
    }
}

추가 폼은 최대 하나의 폼만 띄우도록 합시다. 이를 위해 MainForm에는 추가 폼을 참조하는 멤버 필드를 선언합니다.

AddForm af = null;

MainForm의 Load 이벤트 핸들러를 추가합시다.

private void MainForm_Load(object sender, EventArgs e)

이벤트 핸들러에서는 BookManager 단일 개체에게 AddedBook 이벤트 핸들러를 등록하여 도서를 추가하였을 때 이 사실을 통보받아 처리할 수 있게 합니다.

BM.AddedBook += new BookEventHandler(BM_AddedBook);

BM_AddedBook 이벤트 핸들러에서는 도서 개체를 항목으로 추가합니다.

void BM_AddedBook(object sender, BookEventArgs e)
{
    lbox_book.Items.Add(e.Book);
}

추가 버튼인 btn_add의 Click 이벤트 핸들러를 추가합시다.

private void btn_add_Click(object sender, EventArgs e)

만약 추가 폼을 참조하는 af가 null이면 추가 폼을 생성합니다. 그리고 추가 폼이 닫히는 것을 인지하기 위해 af의 FormClosed 이벤트 핸들러를 추가합니다. 그리고 추가 폼을 시각화합니다.

if (af == null)
{
    af = new AddForm();
    af.FormClosed += new FormClosedEventHandler(af_FormClosed);
    af.Show();
}

af_FormClosed 이벤트 핸들러에서는 af를 null로 설정합니다. 이 작업으로 다시 추가 버튼을 클릭하면 추가 폼을 생성하여 시각화할 수 있는 것입니다.

void af_FormClosed(object sender, FormClosedEventArgs e)
{
    af = null;
}

도서 목록 상자의 항목 변경 이벤트 핸들러를 추가합니다. 이벤트 핸들러에서는 선택한 항목의 도서 개체를 참조하여 BookControl인 bc의 Book 속성을 설정합니다.

private void lbox_book_SelectedIndexChanged(object sender, EventArgs e)
{
    if (lbox_book.SelectedIndex == -1)
    {
        return;
    }
    Book book = lbox_book.SelectedItem as Book;
    bc.Book = book;
}

▶ MainForms.cs

using System;
using System.Windows.Forms;
using BookControlLib;
using BookLib;
 
namespace 도서관리자
{
    public partial class MainForm : Form
    {
        AddForm af = null;
        BookManager BM
        {
            get
            {
                return BookManager.BM;
            }
        }
        public MainForm()
        {
            InitializeComponent();
        }
       
        private void MainForm_Load(object sender, EventArgs e)
        {
            BM.AddedBook += new BookEventHandler(BM_AddedBook);
        } 
        void BM_AddedBook(object sender, BookEventArgs e)
        {
            lbox_book.Items.Add(e.Book);
        }
        private void btn_add_Click(object sender, EventArgs e)
        {
            if (af == null)
            {
                af = new AddForm();
                af.FormClosed += new FormClosedEventHandler(af_FormClosed);
                af.Show();
            }
        }
 
        void af_FormClosed(object sender, FormClosedEventArgs e)
        {
            af = null;
        }
 
        private void lbox_book_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (lbox_book.SelectedIndex == -1)
            {
                return;
            }
 
            Book book = lbox_book.SelectedItem as Book;
            bc.Book = book;
        }
    }
}

이제 AddForm을 구현합시다.

MainForm과 마찬가지로 BookManger를 쉽게 참조할 수 있게 속성을 정의합니다.

BookManager BM
{
    get
    {
        return BookManager.BM;
    }
}

추가 버튼의 Click 이벤트 핸들러를 추가합니다.

private void btn_add_Click(object sender, EventArgs e)

도서 정보를 입력한 컨트롤의 Text 속성으로 도서 정보를 얻어옵니다.

string title = tbox_title.Text;
string isbn = tbox_isbn.Text;
string author = tbox_author.Text;
string publisher = tbox_publisher.Text;
string description = tbox_description.Text;

도서 관리자 단일 개체의 AddBook 메서드를 이용하여 도서 정보를 추가합니다. 만약 결과가 false이면 메시지 창으로 추가 실패를 통보합니다.

if (BM.AddBook(title, isbn, author, publisher, description) == false)
{
    MessageBox.Show("추가 실패");
}

마지막으로 컨트롤의 Text 속성을 초기화합니다.

ControlTextInitialize();

도서 정보를 입력하는 TextBox 컨트롤들의 Text 속성을 초기화하는 메서드를 추가합니다.

private void ControlTextInitialize()
{
    tbox_title.Text = string.Empty;
    tbox_author.Text = string.Empty;
    tbox_isbn.Text = string.Empty;
    tbox_publisher.Text = string.Empty;
    tbox_description.Text = string.Empty;
}

취소 버튼의 Click 이벤트 핸들러도 추가하여 ControlTextInitialize 메서드를 호출합니다.

private void btn_cancel_Click(object sender, EventArgs e)
{
    ControlTextInitialize();
}

이상으로 사용자 정의 컨트롤을 정의하고 이를 이용하는 Windows Forms 응용을 만들어 보았습니다. Windows Forms 응용을 만드는 기술 학습으로는 많은 부분에서 부족할 수 있지만 기본적인 사항을 소개하는 수준에서 끝낼게요. 앞으로 검색 엔진을 만드는 과정을 소개하면서 보다 다양한 실습을 할 수 있을 것입니다. 그리고 필요하시면 별도의 레퍼런스를 참고하시기 바랍니다.

▶ AddForm.cs

using System;
using System.Windows.Forms; 
namespace 도서관리자
{
    public partial class AddForm : Form
    {
        BookManager BM
        {
            get
            {
                return BookManager.BM;
            }
        }
        public AddForm()
        {
            InitializeComponent();
        }
        private void btn_add_Click(object sender, EventArgs e)
        {
            string title = tbox_title.Text;
            string isbn = tbox_isbn.Text;
            string author = tbox_author.Text;
            string publisher = tbox_publisher.Text;
            string description = tbox_description.Text;
            if (BM.AddBook(title, isbn, author, publisher, description) == false)
            {
                MessageBox.Show("추가 실패");
            }
            ControlTextInitialize();
        } 
        private void ControlTextInitialize()
        {
            tbox_title.Text = string.Empty;
            tbox_author.Text = string.Empty;
            tbox_isbn.Text = string.Empty;
            tbox_publisher.Text = string.Empty;
            tbox_description.Text = string.Empty;
        }
 
        private void btn_cancel_Click(object sender, EventArgs e)
        {
            ControlTextInitialize();
        }
    }
}

언제나휴일 여행 및 산책

아산 외암민속마을

1. 5 라이브러리

언휴 — Sun, 19 Jan 2025 11:35:53 +0900

.NET 프레임워크 기반의 라이브러리는 .NET 어셈블리라고 부릅니다.

.NET 어셈블리는 .NET 프레임워크 응용 프로그램을 구성하는 기본 컴포넌트입니다. 컴포넌트 기반의 프로그래밍은 모듈의 재사용성을 높여줍니다. .NET 응용 프로그램을 제작할 때 미리 작성된 라이브러리를 사용할 수 있는데 이 때 사용하는 라이브러리도 .NET 어셈블리이며 실행 파일도 .NET 어셈블리입니다.

.NET 어셈블리는 EXE 파일 혹은 DLL 파일 형태로 만들 수 있으며 하나 이상의 모듈을 포함할 수도 있습니다.

.NET 어셈블리는 자기 기술적인 메타 데이터를 갖고 있고 레지스트리 항목에 종속되지 않는 구성 요소로 디자인되어 있기 때문에 병행(Side by Side) 실행이 가능합니다.

이로써 같은 명칭의 여러 어셈블리를 설치 가능할 뿐만 아니라 이를 사용하는 응용들은 자신들에 맞는 어셈블리를 사용할 수 있습니다.

1.5.1 .NET 어셈블리 구성 요소

.NET 어셈블리는 여러 종류의 구성 요소로 구성합니다.

첫 번째 구성 요소로 어셈블리 매니페스트가 있습니다. 어셈블리 매니페스트는 어셈블리의 버전 요구 사항과 보안 ID를 지정하는 데 필요한 모든 메타데이터와 어셈블리의 범위를 정의하고 참조를 확인하는 데 필요한 모든 메타 데이터를 포함하고 있습니다. 어셈블리 매니페스트는 어셈블리 이름, 버전 번호, 문화권, 강력한 이름의 정보, 어셈블리에 포함한 파일 목록, 형식 참조 정보로 구성합니다.

그리고 어셈블리에 정의된 형식들에 대한 형식 메타 데이터와 실제 수행해야 할 코드인 MSIL과 리소스로 구성합니다.

어셈블리는 하나의 물리적 바이너리로 만들어진 단일 파일 어셈블리와 여러 개의 물리적 바이너리로 만들어진 다중 파일 어셈블리로 나눌 수 있습니다. .NET에서는 어셈블리의 부속으로 사용하는 모듈을 만들 수 있는데 모듈은 어셈블리의 내용으로 포함합니다. 즉, 하나의 어셈블리가 다른 어셈블리에 있는 형식을 사용하기 위해서는 단순히 사용할 어셈블리를 참조만 하면 되는데 모듈에 있는 것을 사용할 때는 모듈을 포함하여 어셈블리를 만들어야 합니다.

그리고 .NET 어셈블리를 구성하는 물리적 바이너리에는 리소스 파일, 매니페이스, DLL, 모듈 등이 있습니다.

1.5.2 .NET 어셈블리 만들기

여기서는 .NET 어셈블리를 만들어 보기로 합시다. .NET 어셈블리 중에 실행 파일을 만드는 것은 이미 알고 있으므로 라이브러리를 만드는 것을 하겠습니다.

.NET에서 라이브러리는 쉽게 제작할 수 있습니다. 코드를 작성하는 부분에서 다른 어셈블리에서 사용할 수 있는 형식을 정의할 때 public 키워드를 명시합니다. 멤버도 마찬가지로 다른 어셈블리에서 접근을 허용하게 하려면 접근 지정을 public으로 설정합니다.

즉 다른 어셈블리에 정의된 형식이나 멤버 중에 사용할 수 있는 형식과 멤버는 접근 지정이 public으로 되어 있다는 것 말고는 차이가 없습니다.

public class Member
{
    ...중략...
    public Member(string name, string addr)
    {
        ...중략...
    }
}

간단한 라이브러리를 하나 만들어 봅시다. 먼저 컴파일러 옵션을 이용하여 만드는 것을 보여 드리고 통합 개발 환경에서 만드는 것을 보여 드릴게요.

컴파일러 옵션을 이용하는 것을 보여 드리기 전에 메모장을 이용하여 소스 코드를 편집해 봅시다. 편집할 코드에는 다른 어셈블리에서 접근할 수 있는 Member 클래스와 접근할 수 없는 MemberInfo 클래스를 정의할게요.

그리고 Member에는 이름과 주소를 입력 인자로 받는 생성자와 이름 속성, 주소 속성의 get 블록을 public으로 접근 지정하여 다른 어셈블리에서 사용할 수 있게 합시다.

▷ 라이브러리 코드 예(Member.cs)

namespace MemberLib
{
    public class Member //다른 어셈블리에서 접근 가능
    {
        MemberInfo mi = null;

        public string Name //다른 어셈블리에서 접근 가능
        {
            get
            {
                return mi.Name;
            }
        }
        public string Addr //다른 어셈블리에서 접근 가능
        {
            get
            {
                return mi.Addr;
            }
        }
        public Member(string name, string addr) //다른 어셈블리에서 접근 가능
        {
            mi = new MemberInfo(name, addr);
        }
        public override string ToString()//다른 어셈블리에서 접근 가능
        {
            return mi.ToString();
        }
    }

    class MemberInfo //다른 어셈블리에서 접근 불가
    {
        internal string Name
        {
            get;
            private set;
        }
        internal string Addr
        {
            get;
            private set;
        }
        internal MemberInfo(string name, string addr)
        {
            Name = name;
            Addr = addr;
        }
        public override string ToString()
        {
            return Name;
        }
    }
}

Visual Studio 명령 프롬프트에서 csc /t:library /out:MemberLib Member.cs를 입력하시면 컴파일되어 MemberLib.dll 파일명으로 .NET 어셈블리가 만들어집니다.

[그림 1.3] csc 명령어를 이용하여 .NET 어셈블리 만들기

다음은 콘솔 명령어 csc의 옵션들입니다.

▷ 기본 옵션

/out:<file>                 만들어질 어셈블리 이름(출력 파일 이름)을 지정
/target:exe                 콘솔 실행 파일을 만들기 (기본) (약식: /t:exe)
/target:winexe             Windows 실행 파일을 만들기 (약식: /t:winexe)
/target:library              라이브러리를 만들기 (약식: /t:library)
/target:module            모듈을 만들기 (약식: /t:module)
/delaysign[+|]              어셈블리 서명을 연기
/doc:<file>                 XML 문서 파일 생성
/keyfile:<file>             강력한 이름의 키 파일을 지정
/keycontainer:<string> 강력한 이름의 키 컨테이너를 지정
/platform:<string>       실행할 수 있는 플랫폼을 지정 (x86, Itanium, x64,anycpu)

▷ 자주 사용하는 옵션

/reference:<file list>      어셈블리 참조 (약식:/r)
/addmodule:<file list>   모듈을 포함
/help                          csc 커맨드 사용법 (약식:/?)
/lib:<file list>               참조를 검색할 추가 디렉터리를 지정

Microsof Visual Studio로 라이브러리를 만들 때는 다음과 같이 새 프로젝트 템플릿에서 클래스 라이브러리를 선택하여 만들면 됩니다.

[그림 1.4] Microsoft Visual Staio에서 클래스 라이브러리 만들기

*개발도구 버전에 따라 다소 차이가 있습니다. *

1.5.3 전용 어셈블리

Microsoft Visual Studio에서 콘솔 응용 프로그램 프로젝트를 생성하여 작성한 어셈블리를 사용하는 코드를 작성해 봅시다.

▶ .NET 어셈블리를 참조하여 사용하는 응용 프로그램 예

using System;
using MemberLib;

namespace UsingMemberLIb
{
    class Program
    {
        static void Main(string[] args)
        {
            Member member = new Member("홍길동", "대한민국");
            Console.WriteLine("이름:{0} 주소:{1}", member.Name, member.Addr);
        }
    }
}

▶ 실행 결과

이름:홍길동 주소:대한민국

물론 MemberLib에서 public으로 지정하지 않은 MemberInfo 형식과 멤버는 사용하지 못합니다.

참고로 CLR은 참조하는 전용 어셈블리의 위치를 찾는 일도 수행하는데 프로빙이라 합니다. 제일 먼저 응용 프로그램 디렉토리를 먼저 검사하고 없으면 구성 파일에 명시된 디렉토리를 검사합니다. 구성 파일은 응용 프로그램 구성 파일과 게시자 정책 파일, 시스템 구성 파일이 있으며 자세한 사항은 MSDN 런타임에서 어셈블리를 찾는 방법을 참고하세요.

1.5.4 공용 어셈블리

공용 어셈블리는 전역 어셈블리 캐시(윈도우즈 설치 폴더의 하위 폴더명이 Assembly인 폴더를 말함)에 있는 어셈블리를 말합니다. 전역 어셈블리 캐시에는 파일명과 확장자가 같더라도 어셈블리의 강력한 이름이 다르다면 배포할 수 있습니다.

[그림 1.6] 전역 어셈블리 캐쉬

*윈도우즈 버전에 따라 다를 수 있음*

강력한 이름은 어셈블리 이름, 버전 번호, 문화권, 어셈블리 ID, 공개 키, 디지털 서명 등으로 구성합니다. 이처럼 전역 어셈블리 캐시에는 같은 이름의 DLL도 강력한 이름이 다르면 배포할 수 있습니다. 이로써 서로 다른 버전을 사용하는 응용 프로그램들이 자신에게 맞는 어셈블리를 사용할 수 있는 것입니다. 이를 병행(Side by Side) 실행이라 합니다.

간단하게 라이브러리를 만들고 병행 실행을 확인합시다.

▶ DemoLib (버전 1.0.0.0)

using System;
namespace DemoLib
{
    public class DemoClass
    {
        public void Foo()
        {
            Console.WriteLine("Foo 1");
        }
    }
}

공용 어셈블리를 만들기 위해 솔루션 탐색기에 프로젝트에 우측 마우스를 클릭하여 나오는 컨텍스트 메뉴에서 속성을 선택하세요. 그리고 서명 탭을 선택하신 후에 어셈블리 서명 체크 박스를 선택하시고 강력한 이름 키 선택 콤보 박스에서 새로 만들기를 선택합니다. 강력한 이름 키 만들기 창에서 키 이름을 입력하면 프로젝트 항목에 만든 키가 보이게 됩니다.

[그림 1.8] 강력한 이름의 키 만들기

그리고 프로젝트를 빌드하시면 출력 폴더(기본: Debug)에 DLL 파일이 만들어집니다.

이제 작성한 DLL을 전역 어셈블리 캐시에 배포합시다. Windows7부터는 보안이 강화되어 관리자 권한으로 배포해야 합니다. 관리자 권한으로 Visual Studio 명령 프롬프트를 실행한 후에 gacutil /i demolib.dll 을 치면 배포가 됩니다.

[그림 1.9] gacutil 명령어로 전역 어셈블리 캐시에 배포

이제 배포한 공용 어셈블리를 사용하는 응용 프로그램 프로젝트를 생성하세요. 그리고 참조 추가를 통해 demolib.dll를 추가하세요. 전용 어셈블리에서 참조 추가하는 것과 같은 방법입니다.

전용 어셈블리를 참조 추가하면 자동으로 프로젝트 출력 폴더에 참조한 어셈블리 파일이 추가하지만 공용 어셈블리를 참조 추가하면 프로젝트 출력 폴더에 추가하지 않고 전역 어셈블리 캐시에 배포된 것을 사용합니다.

그리고 프로젝트 참조 폴더에 해당 어셈블리에 오른쪽 마우스 버튼을 클릭하여 컨텍스트 메뉴에서 속성을 선택하세요. 속성 창을 보면 특정 버전을 선택할 수 있습니다. 만약, 특정 버전 속성을 false로 설정하면 새로운 버전이 배포되면 자동으로 최신 버전을 사용합니다. 하지만 특정 버전 속성을 true로 설정하면 참조한 버전의 어셈블리를 사용하게 됩니다.

[그림 1.10] 특정 버전 속성 지정

여기서는 병행(Side by Side) 실행을 확인하기 위하여 특정 버전 속성을 True로 합시다. 그리고 사용하는 코드를 작성하여 빌드 후에 실행하세요.

▶ 공용 어셈블리(버전 1.0.0.0)를 사용하는 예제 코드

using DemoLib;

namespace UsingDemoV1
{
    class Program
    {
        static void Main(string[] args)
        {
            DemoClass dc = new DemoClass();
            dc.Foo();
        }
    }
}

▶ 실행 결과

Foo 1

그리고 DemoLib를 수정합시다. 조금 전에 만든 DemoLib를 사용하는 프로젝트는 닫아주세요.

▶ DemoLib (버전 1.0.0.1)

using System;
namespace DemoLib
{
    public class DemoClass
    {
        public void Foo()
        {
            Console.WriteLine("Foo 2");
        }
    }
}

프로젝트 속성 창을 열어서 응용 프로그램 탭에 어셈블리 정보 버튼을 클릭합시다. 그리고 버전 정보를 수정하세요. 버전 정보를 수정하였으므로 조금 전에 만들어 배포한 어셈블리와 파일명과 확장자는 같지만 강력한 이름은 다릅니다. 전역 어셈블리 캐시에서는 강력한 이름으로 배포하기 때문에 재배포 가능합니다.

[그림 1.11] 어셈블리 버전 수정

프로젝트를 빌드한 후 gacutil 명령어를 이용하여 다시 배포합시다. 그리고 방금 만들었던 응용을 실행해서 참조한 버전의 어셈블리를 사용하고 있음을 확인하세요.

그리고 새로운 버전을 참조하여 사용하는 응용 프로그램을 작성해 보세요. 그리고 두 개의 응용 프로그램을 실행해 보시면 각각 자신이 참조하는 버전의 어셈블리를 사용함을 확인하실 수 있습니다.

1.5.5 XML 문서 파일

이번에는 라이브러리를 만들 때 사용하는 곳에서 Microsoft Visual Studio의 인텔리센스 기능을 활용할 수 있게 해 봅시다.

프로젝트 속성 창에서 빌드 탭을 선택하여 XML 문서 파일을 체크하세요.

[그림 1.12] XML 문서 파일 출력 설정

그리고 빌드하면 공개한 멤버 형식에 주석이 없다는 경고 메시지가 나타납니다. XML 문서 파일 출력을 설정하면 가시성이 public인 형식과 멤버에 대한 세 줄 주석으로 XML 양식에 맞는 설명이 없으면 경고 메시지가 뜹니다. 다음과 같이 코드를 약간 변경한 후에 주석을 달아봅시다.

▶ XML 양식에 맞게 세 줄 주석 달기

▶ XML 양식에 맞게 세 줄 주석 달기

using System;

namespace DemoLib
{
    /// <summary>
    /// 데모 클래스
    /// </summary>
    public class DemoClass
    {
        /// <summary>
        /// Foo 메서드
        /// </summary>
        /// <param name="a">첫번째 인자 </param>
        /// <param name="b">두번째 인자 </param>
        /// <returns> 첫번째 인자 + 두번째 인자 </returns>
        public int Foo(int a,int b)
        {
            Console.WriteLine("a:{0} b:{1}",a,b);
            return a + b;
        }
    }
}

다시 빌드하시면 경고가 사라지고 출력 폴더에 가 보면 XML 파일이 생긴 것을 확인할 수 있습니다.

▶ XML 출력 파일 내용

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>DemoLib</name>
    </assembly>
    <members>
        <member name="T:DemoLib.DemoClass">
            <summary>
            데모 클래스
            </summary>
        </member>
        <member name="M:DemoLib.DemoClass.Foo(System.Int32,System.Int32)">
            <summary>
            Foo 메서드
            </summary>
            <param name="a">첫 번째 인자</param>
            <param name="b">두 번째 인자</param>
            <returns> 첫 번째 인자 + 두 번째 인자</returns>
        </member>
    </members>
</doc>

그리고 콘솔 응용 프로그램을 생성한 후에 라이브러리를 참조 추가하고 천천히 Demo 형식의 개체를 생성하고 Foo 메서드를 호출하는 구문을 추가해 보세요. 다음처럼 인텔리센스 기능이 작동하여 메서드가 무엇을 의미하는지 인자가 무엇인지 설명하는 구문을 확인할 수 있습니다. 물론, 풍선 도움말에 나타나는 것은 XML 형식에 맞게 작성한 세 줄 주석에 작성한 내용입니다.

[그림 1.13] 인텔리센스 작동 화면

여러 명이 팀 작업을 할 때 이와 같은 기능은 많은 도움을 줍니다. 평소에도 XML 문서 출력 속성을 설정하여 세 줄 주석을 다는 것을 습관화하세요. 자신이 작성한 라이브러리도 사용하기 편하고 다른 동료도 여러분이 만든 라이브러리를 사용하기 편해질 것입니다.

언제나휴일 여행 및 산책

1. 4 요구 기술

언휴 — Sun, 19 Jan 2025 11:25:30 +0900

이 책에서 다루고자 하는 맞춤형 검색 엔진을 만들기 위해서는 라이브러리 제작 기술과 윈도우즈 폼 응용 프로그램 제작 기술 및 .NET 리모팅, DBMS를 사용하기 위해 SQL 쿼리 및 ADO.NET 기술 등이 필요합니다.

기본적으로 이와 같은 기술을 활용해 본 적이 없거나 비슷한 기술을 활용해 본 적이 없으신 분들께서는 별도의 학습이 필요합니다.

여기에서는 간략하게 맞춤형 검색 엔진을 만들기 위해 필요한 요구 기술 중에서 라이브러리 제작 및 윈도우즈 폼 응용 제작 기술 및 .NET 리모팅 기술을 간략하게 소개할게요.

1. 3 시나리오

언휴 — Sun, 19 Jan 2025 11:24:15 +0900

먼저 이 책에서 작성할 맞춤형 검색 엔진 만들기 솔루션의 전반적인 시나리오를 소개할게요. 시나리오는 가상으로 만들었으며 별도의 설명은 하지 않겠습니다.

문서 번호	20XX – P – 01
보존 기간	10년
작성 일자	20XX. X. X
작성자	홍길동

EH-WSE(EH Web Search Engine)

I. 개요

I.1 배경지식

웹 검색 엔진이란 원하는 웹 사이트를 검색하기 위한 S/W를 말합니다. 웹 검색 엔진은 대부분 인터넷 상에 게시되어 있는 웹 페이지들을 수집하는 웹 로봇과 웹 페이지를 분석하는 분석기, 분석한 결과로 쉽게 검색할 수 있게 역 파일을 만드는 색인기 및 질의 결과에 랭킹을 부여하는 랭커 등으로 구성할 수 있습니다. 웹 검색 엔진은 각각의 엔진들의 구동 원리와 구현 수준에 따라 다양한 품질 수준을 결정합니다.

웹 로봇은 일반적으로 여러 개의 Seed 사이트를 일차적으로 수집 대상 페이지로 등록합니다. 그리고 주기적으로 수집 대상 페이지를 수집하고 수집한 웹 페이지 내용에 있는 하이퍼 링크의 웹 사이트도 수집 대상에 추가합니다. 이를 반복하면서 수집하는데 수집한 웹 페이지도 갱신될 개연성이 있으므로 수집한 지 특정 기간이 지난 웹 페이지는 다시 수집 대상에 포함합니다.

웹 페이지 분석기는 웹 페이지의 내용을 공백이나 콤마 등의 약속한 문자를 기준으로 분할하는 방식에서부터 자연어 연구에서 사용하는 형태소 분석까지 다양한 분석기들이 있습니다.

색인기는 웹 페이지 분석기를 통해 분석한 요소별로 해당 요소를 포함한 웹 페이지를 기재하여 검색 요청이 오면 검색 질의를 포함하는 웹 페이지를 검색하기 쉽게 색인 데이터를 만드는 것을 말합니다.

랭커는 질의한 내용으로 검색한 결과들을 다양한 방법에 의해 사용자가 요청하는 질의에 근접한 순위를 부여하는 것을 말합니다. 대표적인 방법으로 문서 내의 검색 요소의 빈도수와 전체 문서에서의 검색 요소를 포함한 문서의 개수를 통해 희귀성을 기반으로 랭킹을 하는 TF-IDF 방식이 있습니다.

I.2 프로젝트 소개

EH WSE 프로젝트는 기본적인 웹 검색 엔진의 구성 요소들을 갖춘 작은 웹 검색 엔진이어야 합니다.

웹 검색 엔진은 관리 응용을 통해 Seed 사이트를 추가하거나 수집을 시작하고 멈출 수 있으며 수집 주기를 정할 수 있어야 합니다. 또한, 관리 응용을 통해 수집 후보 사이트들을 확인할 수 있어야 할 것이며 색인 데이터의 요소 리스트 및 수집한 웹 페이지의 내용도 확인이 가능해야 합니다.

관리 응용을 통해 제어 및 설정하는 검색 엔진은 웹 로봇을 통해 수집하고 분석한 결과 등을 데이터 베이스 관리 시스템을 통해 관리해야 합니다.

검색에 사용하는 응용은 간단한 윈도우 응용 형태로 제작하여 문장이나 단어로 검색할 수 있고 검색한 결과 리스트를 랭커에 의해 순위를 부여한 순으로 확인할 수 있고 해당 웹 페이지를 방문할 수 있어야 합니다.

본 프로젝트에서는 웹 로봇의 성능이나 분석기의 품질 및 보안에 관한 품질 수준은 특별히 요구하지 않습니다. 다만, 가급적 엔진들은 분리하고 각 엔진들에서 공통적으로 사용할 형식들은 라이브러리로 만들어 재사용성을 높이고 유지 보수가 쉽게 유연성 있는 결과물을 만들 수 있어야 할 것입니다.

II. 동작 환경 및 요구 기술

II.1 동작환경

O/S : Windows 7

DBMS: MS-SQL 20010

II.2 요구 기술

본 프로젝트를 수행하기 위해서는 C# 언어에 관한 기본 문법을 인지하고 구사할 수 있어야 합니다. Java 언어에 숙달되어 있다면 큰 비용없이 C# 문법에 관한 레퍼런스를 참고하여 작성하는데 무리가 없습니다.

본 프로젝트를 수행하기 위해서는 기본적인 SQL 쿼리문을 알고 있으며 ADO.NET을 사용할 수 있거나 학습을 요구합니다.

본 프로젝트를 수행하기 위해서는 Windows Form에 관한 기본적인 이해 및 사용을 할 수 있거나 학습을 요구합니다.

본 프로젝트를 수행하기 위해서는 .NET 어셈블리에 관한 이해 및 클래스 라이브러리 개발을 할 수 있거나 학습을 요구합니다.

본 프로젝트를 수행하기 위해서는 .NET 리모팅에 관한 이해와 서비스 정의 및 서비스를 사용할 수 있거나 학습을 요구합니다.

본 프로젝트를 수행하기 위해서는 CBD개발 방법론에 대한 기본적인 이해 및 UML을 사용할 수 있거나 학습을 요구합니다.

III. 개발 공정

요구 분석 및 정의 – 10%

아키텍쳐링 – 40%

설계 – 30%

구현 – 20%

배포 – 해당 사항 없음

언제나휴일 여행 및 산책

천안 천호지

1. 2 개요

언휴 — Sun, 19 Jan 2025 11:22:10 +0900

이 책은 웹 검색 엔진을 구성하는 다양한 엔진과 모듈을 제작하는 방법을 다루고 있습니다. 따라서 하나의 프로젝트가 아닌 여러 개의 프로젝트로 나누어 작업을 진행해야 합니다. 그리고 이 책에서는 단순히 웹 검색 엔진을 구현하는 것만을 다루는 것이 아니라 개발 전체 공정에 관해서도 다루고 있습니다.

웹 검색 엔진을 만드는 전체 공정은 시나리오에서 출발하여 요구 분석 및 정의 단계, 아키텍쳐링 단계, 설계 단계, 구현 단계로 나누어 진행할 것입니다. 이를 위해 구현에 필요한 개발 도구만 사용하는 것이 아니라 CASE 도구를 사용하여 다양한 다이어그램을 작성도 해야 합니다.

CASE 도구로는 Rational 사의 Rose, 볼랜드 사의 Together, 오픈 프로젝트인 Star UML 등이 있습니다. 이 책에서는 쉽게 구하고 사용할 수 있는 Star UML을 사용하였습니다.

그리고 개발 환경은 Windows 운영 체제 기반으로 작성하고 언어는 C#으로 작성하였으며 DBMS는 MS SQL 2008 서버를 사용하였습니다. 구체적 구현을 위해 개발 환경 및 언어와 DBMS를 정한 것인데 구현 이전 단계의 대부분은 개발 환경이나 언어 등에 영향을 받지 않는 부분이 많기 때문에 다른 환경과 다른 언어를 사용하는 개발자에게도 도움이 될 것입니다.

특히 Java 언어를 사용하는 개발자는 어느 정도의 응용 능력을 갖고 있다면 충분히 이 책의 내용을 토대로 자신의 환경과 언어로 만드는 것이 문제되지 않을 것입니다. 경우에 따라 이 책의 내용을 이해하고 실습하기 위해 필요한 기술을 학습하면서 부가적인 기술도 습득할 수 있을 것이라 생각합니다.

물론 여러분께서 현재 가지고 있는 지식과 기술만 사용하고 새로운 학습에 도전 정신이 부족하다면 설계 과정이나 구체적 구현 과정에 들어섰을 때 힘들어 질 수도 있습니다.

부디 도전적이고 진취적인 자세로 학습하기를 소망합니다.

언제나휴일 여행 및 산책

아산 외암민속마을

1. 1 검색 엔진

언휴 — Sun, 19 Jan 2025 07:11:09 +0900

여러분도 잘 아시는 것처럼 검색 엔진은 사용자가 원하는 정보를 검색해 주는 도구나 서비스를 말합니다. 특히 웹 검색 엔진은 웹 상에 게시되어 있는 수 많은 웹 페이지의 내용에서 원하는 정보를 검색해 주는 엔진입니다.

이러한 검색 엔진은 방대한 자료에서 빠르고 정확하게 원하는 정보를 검색하는 것이 중요합니다. 만약 자료의 양이 많지 않다면 굳이 고사양의 검색 엔진은 필요하지 않을 것입니다.

따라서 검색 엔진은 방대한 자료를 수집하는 작업이 필요합니다. 그리고 수집한 자료를 분석하는 작업, 분석한 결과를 검색하기 쉽게 가공하는 작업, 검색 작업과 검색한 결과를 선별 및 순위를 정하는 등의 작업이 필요합니다.

웹 검색 엔진의 구성을 살펴보면 게시한 웹 페이지를 수집하는 웹 로봇과 수집한 웹 페이지 내용을 분석하는 분석 로봇, 분석한 결과를 색인하는 색인 로봇, 검색 요청을 받아 색인 자료를 통해 검색 결과를 얻어오는 검색 엔진으로 구성합니다. 그리고 검색 결과를 순위화하는 랭킹 모듈 등을 추가로 구성하여 품질 수준을 높일 수 있습니다.

웹 검색 엔진 구성

언제나휴일 여행 및 산책

독립기념관

1. 검색 엔진 소개 및 개요

언휴 — Sun, 19 Jan 2025 07:09:21 +0900

최근 인터넷의 발달로 다양한 정보를 웹을 통해 얻습니다. 특히 개인 블로그 및 커뮤니티 사이트, 소셜 사이트의 증가로 정보 공급자와 정보 사용자의 경계가 사라져가고 있습니다.

이처럼 다양한 형태의 방대한 자료가 웹 상에 만들어지고 있어 효과적인 검색을 위한 검색 엔진들을 연구하고 만들어지고 있습니다. 특히 검색 엔진은 기존의 포털 사이트에서 제공하는 서비스였지만 소셜 사이트 및 다양한 정보 서비스를 위해 필요한 곳이 많아집니다.

이 책에서는 기존 웹 검색 엔진을 만드는 전체 공정을 순서대로 하나 하나 설명하고 궁극적으로 서비스 목적에 맞는 검색 엔진을 만들 수 있게 할 것입니다.

정보의 바다

언제나휴일 여행 및 산책

아산 외암민속마을

0. 들어가기에 앞서

언휴 — Sun, 19 Jan 2025 07:05:30 +0900

2000년 무렵에 케이블 인터넷과 ADSL기술을 도입하면서 초고속 인터넷을 보급하던 때만 하더라도 웹 사이트에 글을 포스팅하는 것은 업체나 기관에서 할 일이라 생각했지요.

그런데 지금은 SNS의 등장을 비롯하여 많은 곳에서 All IP 시대로 가기 위한 준비를 하면서 웹 사이트를 방문하는 지식 소비자와 웹 사이트를 구축하고 지식 포워딩하는 지식 공급자가 뚜렷하게 나눌 수 없는 프로슈머 형태를 지니고 있습니다.

시멘틱 검색 엔진이라는 것이 세상에 모습을 드러낼 때만 해도 포털 사이트에서만 사용할 기술처럼 생각했습니다. 그리고 새로 포스팅하는 자료의 양이 지금에 비해 적어 높은 수준의 기술을 요구하지 않았었죠. 하지만 지금은 일반 사용자들도 자신의 블로그나 SNS에 일상과 자신의 취미 생활 및 기술을 포스팅하고 있어 압도적인 자료를 새로 생산하고 있으며 이에 높은 기술 수준의 검색 엔진을 요구하고 있습니다.

자료가 많지 않던 시절에는 과도히 많은 자료가 생기면 오히려 필요한 자료를 찾기 힘들다는 논리를 펼치던 시절도 있었습니다. 하지만 지금에 와서는 이들 자료를 효과적으로 통계를 내고 분석하여 필요한 정보를 추출하는 기술의 발달로 자료가 축적되고 변화하는 모습에 따라 지식에도 생명이 있음을 인지하는 수준에 도달하였습니다.

이제 시멘틱 검색 엔진은 포탈 사이트에서만 필요한 기술이 아닌 수 많은 서비스에서 사용해야 할 기술로 변하고 있습니다. 여러분들이 이 책을 통해 시멘틱 검색 엔진을 만들기 위한 기본적인 기술을 익혀 다양한 분야에 활용할 수 있었으면 합니다.

자료가 모이고 이를 통계 및 분석을 통해 지식에 생명을 불어 넣듯이 우리의 기술이 모여 삶의 질 향상에 이바지할 수 있기를 기원합니다.

언제나휴일 여행 및 산책

천안 천호지

[C언어 소스] 연결리스트를 이용하여 구현한 큐

언휴 — Thu, 9 Jan 2025 12:00:50 +0900

[C언어 소스] 연결리스트를 이용하여 구현한 큐

안녕하세요. 언제나 휴일이예요.

이번에는 연결리스트를 이용하여 구현한 큐의 소스 코드예요.

큐는 자료를 한쪽으로 보관하고 다른쪽에서 꺼내는 FIFO(First In First Out) 방식의 자료구조입니다. 큐에 자료를 보관하는 연산을 PUT 혹은 ENQUEUE라 말하고 꺼내는 연산을 GET 혹은 DEQUEUE라고 말합니다. 그리고 보관할 위치 정보를 rear, 꺼낼 위치 정보를 front라고 말해요.

연결리스트를 이용하여 구현한 큐에서는 보관할 때 rear 뒤에 보관하고 꺼낼 때 front에 있는 것을 꺼냅니다. 그리고 보관할 때 허용하는 메모리 범위 내에서 보관할 수 있어 꽉 찼는지 확인할 필요가 없습니다.

알고리즘

PUT 연산
now = MakeNode(data) (노드 생성)

IF Queue Is Empty (비어있을 때)
    front = now (front를 now로 설정)
Else (비어있지 않을 때)

    rear의 next= now (rear의 netx를 now로 설정)
rear=now (rear를 now로 설정)

GET 연산
IF Queue is empty Then (비었으면)
    Underflow (버퍼 언더플로우)
Else
now = front

    data = front의 data (data를 front의 data로 설정)

    fornt =now의 next (front를 now의 next로 설정)

DisposeNode(now) (now 노드 소멸)

data 반환

원형 큐 실행 화면

소스 코드

//큐 - 연결리스트 이용
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Node //노드 정의
{
    int data;
    struct Node *next;
}Node;


typedef struct Queue //Queue 구조체 정의
{
    Node *front; //맨 앞(꺼낼 위치)
    Node *rear; //맨 뒤(보관할 위치)
    int count;//보관 개수
}Queue;

void InitQueue(Queue *queue);//큐 초기화
int IsEmpty(Queue *queue); //큐가 비었는지 확인
void Enqueue(Queue *queue, int data); //큐에 보관
int Dequeue(Queue *queue); //큐에서 꺼냄

int main(void)
{
    int i;
    Queue queue;

    InitQueue(&queue);//큐 초기화
    for (i = 1; i <= 5; i++)//1~5까지 큐에 보관
    {
        Enqueue(&queue, i);
    }
    while (!IsEmpty(&queue))//큐가 비어있지 않다면 반복
    {
        printf("%d ", Dequeue(&queue));//큐에서 꺼내온 값 출력
    }
    printf("\n");
    return 0;
}

void InitQueue(Queue *queue)
{
    queue->front = queue->rear = NULL; //front와 rear를 NULL로 설정
    queue->count = 0;//보관 개수를 0으로 설정
}

int IsEmpty(Queue *queue)
{
    return queue->count == 0;    //보관 개수가 0이면 빈 상태
}

void Enqueue(Queue *queue, int data)
{
    Node *now = (Node *)malloc(sizeof(Node)); //노드 생성
    now->data = data;//데이터 설정
    now->next = NULL;

    if (IsEmpty(queue))//큐가 비어있을 때
    {
        queue->front = now;//맨 앞을 now로 설정       
    }
    else//비어있지 않을 때
    {
        queue->rear->next = now;//맨 뒤의 다음을 now로 설정
    }
    queue->rear = now;//맨 뒤를 now로 설정   
    queue->count++;//보관 개수를 1 증가
}

int Dequeue(Queue *queue)
{
    int re = 0;
    Node *now;
    if (IsEmpty(queue))//큐가 비었을 때
    {
        return re;
    }
    now = queue->front;//맨 앞의 노드를 now에 기억
    re = now->data;//반환할 값은 now의 data로 설정
    queue->front = now->next;//맨 앞은 now의 다음 노드로 설정
    free(now);//now 소멸
    queue->count--;//보관 개수를 1 감소
    return re;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 부분 문자열 복사하는 함수 만들기(버퍼 오버플로우 방지)

언휴 — Thu, 9 Jan 2025 11:30:24 +0900

알고리즘

부분 문자열 복사(dest: 버퍼, dsize:버퍼 길이, src: 원본 문자열, n:복사할 문자 개수)

origin:= dest

반복(dsize와 n이 참이고 dest 가리키는 곳에 src가 가리키는 문자 대입)

dest와 src를 다음 위치로 증가, dsize 1감소, n 1감소

origin 반환

부분 문자열 복사 실행 화면

소스 코드

//부분 문자열 복사하는 함수 만들기 - 버퍼 오버플로우 방지
#include <stdio.h>
#include <string.h>
char *mystrncpy_s(char *dest, size_t dsize, const char *src, size_t n);
int main(void)
{
    char source[100] = "Hello World";
    char dest[100] = "abcde Yahoo";
    
    printf("원본 문자열:%s 의 5개 문자 복사\n", source);
    printf("복사 전 현재 결과 문자열:%s\n", dest);
    mystrncpy_s(dest, sizeof(dest), source, 5);
    printf("복사 후 결과 문자열: %s\n", dest);
    return 0;
}

char *mystrncpy_s(char *dest, size_t dsize, const char *src, size_t n)
{
    char *origin;

    dsize--;//맨 마지막에 종료 문자('\0')를 추가해야 하므로 버퍼 길이를 1 감소    

    //dsize와 n이 참이고 복사한 문자가 참이면 반복
    for (origin = dest; dsize && n && (*dest = *src); dest++, src++, n--, dsize--);
    return origin;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 부분 문자열 복사하는 함수 만들기

언휴 — Thu, 9 Jan 2025 11:00:22 +0900

알고리즘

부분 문자열 복사하기(dest:복사할 버퍼, src: 원본 문자열, n:복사할 문자 개수)

origin:= dest

반복(n이 0보다 크면서 dest가 가리키는 곳에 src가 가리키는 문자 대입)

dest와 src를 다음 위치로 증가, n 1감소

origin 반환

부분 문자열 복사 실행 화면

소스코드

//부분 문자열 복사하는 함수 만들기
#include <stdio.h>

char *mystrncpy(char *dest, const char *src, size_t n);
int main(void)
{
    char source[100] = "Hello World";
    char dest[100] = "abcde Yahoo";

    printf("원본 문자열:%s 의 5개 문자 복사\n", source);
    printf("복사 전 현재 결과 문자열:%s\n", dest);
    mystrncpy(dest, source, 5);
    printf("복사 후 결과 문자열: %s\n", dest);

    return 0;
}

char *mystrncpy(char *dest, const char *src, size_t n)
{
    char *origin;

    //n이 참이고 복사한 문자가 참이면 반복
    for (origin = dest; n && (*dest = *src); dest++, src++, n--);
    return origin;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 문자열 복사하는 함수 만들기(버퍼 오버플로우 방지)

언휴 — Thu, 9 Jan 2025 10:30:18 +0900

알고리즘

문자열 복사하기(dest:복사할 버퍼, dsize:버퍼 길이, src: 원본 문자열)

….dsize 1감소

…..origin:= dest

….반복(dsize가 참이면서 dest가 가리키는 곳에 src가 가리키는 문자 대입)//대입한 결과가 참이면 반복

……..dest와 src를 다음 위치로 증가, dsize 1감소

….dest가 가리키는 곳에 종료 문자 대입

….origin 반환

문자열 복사 실행 화면

소스 코드

//문자열 복사 - 버퍼 오버플로우 방지
#include <stdio.h>

char *mystrcpy_s(char *dest, size_t dsize, const char *src);
int main(void)
{
    char source[100] = "Hello World";
    char dest[100];
    
    printf("원본 문자열:%s\n", source);
    mystrcpy_s(dest, sizeof(dest), source);
    printf("복사 결과 문자열: %s\n", dest);

    return 0;
}

char *mystrcpy_s(char *dest, size_t dsize, const char *src)
{
    char *origin;

    dsize--;//맨 마지막에 종료 문자('\0')를 추가해야 하므로 버퍼 길이를 1 감소

    //dsize가 0이 아니고 복사한 문자가 참이면 반복
    for (origin = dest; (dsize) && (*dest = *src); dest++, src++, dsize--);
    *dest = 0;//종료 문자 복사
    return origin;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 문자열 복사하는 함수 만들기

언휴 — Thu, 9 Jan 2025 10:00:54 +0900

[C언어 소스] 문자열 복사하는 함수 만들기

알고리즘

문자열 복사하기(dest:복사할 버퍼, src: 원본 문자열)

….origin:= dest

….반복(dest가 가리키는 곳에 src가 가리키는 문자 대입) //대입한 결과가 참이면 반복

……..dest와 src를 다음 위치로 증가

….origin 반환

문자열 복사 실행 화면

소스 코드

//문자열 복사하는 함수 만들기
#include <stdio.h>

char *mystrcpy(char *dest, const char *src);
int main(void)
{
    char source[100] = "Hello World";
    char dest[100];

    printf("원본 문자열:%s\n", source);
    mystrcpy(dest, source);
    printf("복사 결과 문자열: %s\n", dest);
    return 0;
}

char *mystrcpy(char *dest, const char *src)
{
    char *origin;
    for (origin = dest; *dest = *src; dest++, src++);//복사한 문자가 참이면 반복
    return origin;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 부분 문자열 비교하는 함수 만들기

언휴 — Thu, 9 Jan 2025 09:30:29 +0900

알고리즘

부분 문자열 비교(str1:비교 대상 문자열1, str2: 비교 대상 문자열 2, n:비교할 문자 개수)

….반복(n이 0보다 크면서 str이 가리키는 문자가 참이면서 str1과 str2가 가리키는 문자가 서로 같으면)

……..str1과 str2를 다음 위치로 이동

……..n을 1 감소

….str1과 str2가 가리키는 문자의 차이 반환

부분 문자열 비교 실행 화면

소스코드

//부분 문자열 비교하는 함수 만들기
#include <stdio.h>

int mystrlen(const char *str);
//사전식 비교: 사전에 앞에 나오는 단어가 작고 뒤에 나오는 단어가 크다고 판별
//차이가 없으면 0 반환
int mystrncmp(const char *str1, const char *str2, size_t n);
int main(void)
{
    char src[100] = "This is test1. He is a student. She is a teacher.";
    char key[10] = "is";
    int len;
    int i;

    len = mystrlen(key);
    printf("원본 문자열:%s\n\n", src);
    printf("is로 시작하는 부분 문자열 목록\n\n");
    for (i = 0; src[i]; i++)
    {
        if (mystrncmp(src + i, key, len) == 0)//부분 문자열 비교 결과가 0일 때
        {
            printf("%s\n", src + i);
        }
    }

    return 0;
}

int mystrlen(const char *str)
{
    int cnt;
    //str[cnt]가 거짓 문자(종료 문자, '\0')가 나올 때까지 cnt를 1증가
    for (cnt = 0; str[cnt]; cnt++);
    return cnt;
}

int mystrncmp(const char *str1, const char *str2, size_t n)
{
    //비교할 개수 n이 0이거나
    //str1이 가리키는 문자가 종료 문자나 str1과 str2가 가리키는 문자가 다를 때까지 반복
    for (n--; n&& *str1 && (*str1 == *str2); str1++, str2++)
    {
        n--;
    }
    return *str1 - *str2;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 문자열 비교하는 함수 만들기

언휴 — Thu, 9 Jan 2025 07:52:49 +0900

알고리즘

문자열 비교하기(str1:비교 대상 문자열1, str2: 비교 대상 문자열 2)

….반복(str이 가리키는 문자가 참이면서 str1과 str2가 가리키는 문자가 서로 같으면)

………str1과 str2를 다음 위치로 이동

….str1과 str2가 가리키는 문자의 차이 반환

문자열 비교 출력 화면

소스코드

//문자열 비교하는 함수 만들기
#include <stdio.h>
//사전식 비교: 사전에 앞에 나오는 단어가 작고 뒤에 나오는 단어가 크다고 판별
//차이가 없으면 0 반환
int mystrcmp(const char *str1, const char *str2);
int main(void)
{
    char names[5][20] =
    {
        "홍길동","강감찬","이순신","을지문덕","한석봉"
    };
    char name[20];
    int i = 0;
    int value;

    printf("검색할 이름 :");
    scanf_s("%s", name, sizeof(name));

    printf("사전식 비교: 사전에 앞에 나오는 단어가 작고 뒤에 나오는 단어가 크다고 판별\n");
    for (i = 0; i<5; i++)
    {
        value = mystrcmp(name, names[i]);
        if (value == 0)//차이가 없을 때
        {
            printf("인덱스 %d에서 %s를 찾았습니다. \n", i, name);
        }
        else
        {
            if (value>0)
            {
                printf("%s > %s \n", name, names[i]);
            }
            else
            {
                printf("%s < %s \n", name, names[i]);
            }
        }
    }


    return 0;
}

int mystrcmp(const char *str1, const char *str2)
{
    //str1이 가리키는 문자가 종료 문자나 str1과 str2가 가리키는 문자가 다를 때까지 반복
    for (; *str1 && (*str1 == *str2); str1++, str2++);
    return *str1 - *str2;
}

언제나휴일 여행 및 산책

[C언어 소스] 문자열 길이를 계산하는 함수 만들기

언휴 — Wed, 8 Jan 2025 18:20:28 +0900

[C언어 소스] 문자열 길이를 계산하는 함수 만들기

알고리즘

문자열 길이 구하기(str:문자열 시작 위치)

cnt:=0

반복(str[cnt]가 참인 문자)

cnt 1 증가

cnt 반환

문자열 길이 구하여 출력

소스 코드

//문자열 길이 구하는 함수 만들기
//참고 <string.h>에 strlen 함수가 있습니다.
#include <stdio.h>

int mystrlen(const char *str);
int main(void)
{
    char name[100] = "Hello World";
    printf("%s\n", name);
    printf("길이: %d\n", mystrlen(name));
    return 0;
}

int mystrlen(const char *str)
{
    int cnt;
    //str[cnt]가 거짓 문자(종료 문자, '\0')가 나올 때까지 cnt를 1증가
    for (cnt = 0; str[cnt]; cnt++);
    return cnt;
}

언제나휴일 여행 및 산책

독립기념관

[C언어] n 개의 정수 중에 홀수의 합계 구하는 함수 만들기

언휴 — Wed, 8 Jan 2025 17:18:51 +0900

n 개의 정수를 표현하기 가장 적합한 자료 형식은 정수 형식을 원소로 하는 배열이겠죠.

n을 10으로 하드 코딩한다면 다음과 같습니다.

int arr[10];

제일 먼저 함수 이름을 결정합시다.

홀수 합계를 구하는 것이므로 GetOddSum 이라고 정할게요.

n개의 정수 중에 홀수의 합계를 구하는 함수의 함수 원형을 정해봅시다.

C언어에서 배열 이름은 할당한 메모리 주소입니다. 해당 주소에 원소 형식을 사용할 것이므로 원소 형식 포인터로 생각할 수 있어요.

그리고 배열의 크기를 전달해야겠죠.

따라서 입력 매개변수는 2개로 int *base, int size 정도면 적당하겠네요.

*원소 개수가 음수가 올 수 없다는 것을 고려한다면 unsigned 은 size_t로 표현할 수도 있어요.*

함수에서는 결과로 홀수의 합계를 반환해야 하기 때문에 int 형식을 반환 형식으로 정할 수 있겠네요.

따라서 함수 원형은 다음처럼 정하면 적당한 수준이겠죠.

int GetOddSum(int *base, int asize);

보다 높은 신뢰성을 추구한다면 전달받은 주소의 값을 바꿀 수 없게 const int *base로 정하면 보다 높은 신뢰성을 추가할 수 있어요.

int GetOddSum(const int *base, int asize);

사용하는 예를 포함하면 다음처럼 작성할 수 있을 거예요.

#include <stdio.h>

int GetOddSum(const int* base, int asize);
int main()
{
    int arr[10] = { 1,2,3,7,8,5,4,9,11,6 };
    printf("홀수의 합계:%d\n", GetOddSum(arr, 10));

    return 0;
}
int GetOddSum(const int* base, int asize)
{
    int sum = 0;
    for (int i = 0; i < asize; i++)
    {
        if (base[i] % 2 == 1)
        {
            sum += base[i];
        }
    }
    return sum;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 속이 빈 삼각형 출력

언휴 — Wed, 8 Jan 2025 17:16:47 +0900

알고리즘

n:←높이 입력

반복(space:1→(n-1))

공백 출력

‘*’출력

개행 출력

반복(line:1→n-2)

반복(space:1→n-line-1)

공백 출력

‘*’출력

반복(space:1→2line-1)

공백 출력

‘*’ 출력

개행

반복(star:1→(2n-1))

‘*’출력

개행

속이 빈 삼각형 출력 화면

소스코드

//반복문 연습 - 속이 빈 삼각형

//입력
//5                - n

//출력
//     *            공백 4, 별1, 개행
//    * *           1- 공백 3, 별1, 공백1,별1, 개행 
//   *   *          2- 공백 2, 별1, 공백3,별1, 개행
//  *     *         3- 공백 1, 별1, 공백5,별1, 개행
// *********      공백0, 별9, 개행

//공백 = n-1, 별1, 개행
//line: 1~(n-2)
//공백 = n-line-1
//별1
//공백 = 2*line-1
//별1
//개행=1
//별 = 2*n -1, 개행

#include <stdio.h>
int main(void)
{
    int n;
    int line, space, star;

    printf("높이:");
    scanf_s("%d", &n);//입력
    for (space = 1; space <= (n - 1); space++)//공백 = n-line
    {
        putchar(' ');
    }
    putchar('*');//별1
    putchar('\n');//개행
    for (line = 1; line <= (n - 2); line++)//line: 1~(n-2)
    {
        for (space = 1; space <= (n - line - 1); space++) //공백 = n-line-1
        {
            putchar(' ');
        }
        putchar('*');//별1
        for (space = 1; space <= 2 * line - 1; space++) //공백 = 2*line-1
        {
            putchar(' ');
        }
        putchar('*');//별1
        putchar('\n');//개행=1
    }
    for (star = 1; star <= (2 * n - 1); star++)//별 = 2*n -1
    {
        putchar('*');
    }
    putchar('\n');//개행
    return 0;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 산봉우리 출력

언휴 — Wed, 8 Jan 2025 17:13:55 +0900

알고리즘

n:←산의 높이 입력

반복(line:1→2n)

조건(line<=n)

반복(space:1→4n-1-line)

공백 출력

반복(star:1→2line-1)

‘*’ 출력

개행

아니면

반복(space:1→2n-line)

공백 출력

반복(start:1→2(line-n))

‘*’ 출력

반복(space:1→2(2n-line))

공백 출력

반복(star:1→(2n-line-1))

‘*’ 출력

반복(space:1→2(2n-line))

공백 출력

반복(start:1→2(line-n))

‘*’ 출력

개행

산 출력

소스코드

//반복문 연습 - 산봉우리 출력

//입력
//5                - n

//출력
//                    *                          1                        공백(9+9),별1, 개행
//                   ***                         2                        공백(9+8), 별3, 개행
//                  *****                        3                        공백(9+7),별5, 개행
//                 *******                       4                         공백(9+6), 별7, 개행
//                *********                      5                         공백(9+5), 별9, 개행
//     *         ***********          *          6  공백4, 별1, 공백4, 공백4, 별11, 공백4, 공백4, 별1, 개행
//    ***      *************        ***          7  공백3, 별3, 공백3, 공백3, 별13, 공백3, 공백3, 별3, 개행
//   *****    ***************     *****          8  공백2, 별5, 공백2, 공백2, 별15, 공백2, 공백2, 별5, 개행
//  *******  *****************  *******          9  공백1, 별7, 공백1, 공백1, 별17, 공백1, 공백1, 별7, 개행
// *************************************        10   공백0, 별9, 공백0, 공백0, 별19, 공백0, 공백 0, 별9,개행

//line:1~2*n
//조건(line<=n)이 참일 때
//공백= (2*n-1)+(2*n-line) = 4*n -1-line
//별 = 2*line-1
//개행
//조건(line<=n)이 거짓일 때
//공백 = 2*n-line
//별 = 2*(line-n)-1
//공백 = 2*(2*n-line)     
//별 = 2*line-1
//공백 = 2*(2*n-line)
//별 = 2*(line-n)-1
//개행

#include <stdio.h>

int main(void)
{
    int n;
    int line, space, star;

    printf("높이:");
    scanf_s("%d", &n);//입력

    for (line = 1; line <= 2 * n; line++)//line: 1~2n
    {
        if (line <= n)//line is 1~n
        {
            for (space = 1; space <= (4 * n - 1 - line); space++)//공백 4*n - 1 - line개
            {
                putchar(' ');
            }
            for (star = 1; star <= (2 * line - 1); star++)//별 2*line -1개
            {
                putchar('*');
            }
            putchar('\n');//개행
        }
        else//line is n+1 ~ 2n
        {
            for (space = 1; space <= (2 * n - line); space++)//공백 2n-line개
            {
                putchar(' ');
            }
            for (star = 1; star <= 2 * (line - n) - 1; star++)//별 2*(line-n)-1개
            {
                putchar('*');
            }
            for (space = 1; space <= (2 * (2 * n - line)); space++)//공백 2*(2*n-line) 개
            {
                putchar(' ');
            }
            for (star = 1; star <= (2 * line - 1); star++)//별 2*line-1개
            {
                putchar('*');
            }
            for (space = 1; space <= (2 * (2 * n - line)); space++)//공백 2*(2*n-line) 개
            {
                putchar(' ');
            }
            for (star = 1; star <= 2 * (line - n) - 1; star++)//별 2*(line-n)-1개
            {
                putchar('*');
            }
            putchar('\n');//개행
        }
    }
    return 0;
}

언제나휴일 여행 및 산책

독립기념관

[C언어 소스] 숫자 피라미드

언휴 — Wed, 8 Jan 2025 17:08:33 +0900

[C언어 소스] 숫자 피라미드

다음처럼 출력할 라인 수를 입력하여 정수 피라미드를 출력하시오.

숫자 피라미드

라인 수 입력

Loop(i:1->line)

Loop(space:0->line-1)

printf space

Loop(num:1->i)

print num

Loop(num:i-1->1)

print num

#include <stdio.h>
int main()
{
    int line = 0;
    int num = 0, i = 0, space = 0;
    printf("정수:");
    scanf_s("%d", &line);

    for (i = 1; i <= line; i++) //입력한 line번 반복
    {
        //i번 라인에 공백은 (line-i)개 출력
        for (space = 0; space < (line - i); space++)
        {
            putchar(' ');
        }
        //1부터 i까지 증가하면서 출력
        for (num = 1; num <= i; num++)
        {
            printf("%d", num);
        }
        //i-1번부터 1까지 감소하면서 출력
        for (num = i-1; num > 0; num--)
        {
            printf("%d", num);
        }
        putchar('\n');//개행 출력
    }

    return 0;
}

언제나휴일 여행 및 산책

Queue를 이용한 스케쥴러 시뮬레이션 [C++]

언휴 — Wed, 8 Jan 2025 16:00:40 +0900

Queue를 이용한 스케쥴러 시뮬레이션 [C++]

안녕하세요. 언제나 휴일에 언휴예요.

이번 실습은 Queue를 이용한 스케쥴러 시뮬레이션입니다.

스케쥴러는 운영체제의 핵심 개체로 누가 CPU를 점유하여 사용할 것인지를 판단하는 역할을 수행합니다.

여기에서는 대기 큐를 이용하는 라운드 로빈 방식의 스케쥴러를 코드로 표현해 볼게요.

보다 자세한 사항은 자료구조와 알조리즘 C++ 3.5 큐를 이용한 스케쥴러 시뮬레이션을 참고하세요.

EHProcess.H

#include 
using namespace std;
class EHProcess
{
    string pname; //프로그램 이름
    const int tjob; //전체 작업량
    const int cjob; //cpu 점유 시 수행가능 최대 작업량
    int ntjob; //현재 남은 작업량
    int ncjob; //현재 cpu 점유 시 수행가능 최대 작업량
public:
    EHProcess(string pname,int tjob,int cjob);
    void IdleToReady();//Idle 상태에서 Ready 상태로 전이
    int Running();//CPU를 점유하여 실행, 남은 작업량 반환
    void EndProgram(); //프로세스 종료
};

EHProcess.cpp

#include "EHProcess.h"
EHProcess::EHProcess(string pname,int tjob,int cjob):tjob(tjob),cjob(cjob)
{
    this->pname = pname;
}
void EHProcess::IdleToReady()//Idle 상태에서 Ready 상태로 전이
{
    cout<<pname<<" 총 작업량:"<<tjob<<" CPU 점유시 작업량:"<<cjob<<endl;
    ntjob = tjob; //프로그램 이미지 메모리에 로딩을 표현
}
#include 
int EHProcess::Running()//CPU를 점유하여 실행, 남은 작업량 반환
{
    cout << pname << " CPU 점유" << endl;
    ncjob = cjob; //ncjob에 CPU 사용할 수 있는 시간 대입    
    for(  ; ntjob && ncjob ; ntjob--, ncjob--)
    {
        Sleep(300);
        cout<<ntjob<<" ";//단위 시간 작업 수행을 표현
    }
    cout <<endl;//CPU를 반납함을 표현
    return ntjob; //남은 작업량 반환
}
void EHProcess::EndProgram() //프로세스 종료
{
    cout<<pname<<"종료"<<endl; //프로세스 종료를 표현
}

Scheduler.h

//Scheduler.h
#pragma once
#include 
#include 
using namespace std;
#include "EHProcess.h"
typedef vector Memory;
typedef queue ReadyQueue;
typedef Memory::iterator miter;
class Scheduler  
{
    Memory hard_disk; // 하드디스크
    ReadyQueue  rq; //대기 큐
public:
    Scheduler();
    void Simulation();//시뮬레이션 시작
    virtual ~Scheduler();
private:
    void Init(); //시뮬레이션 초기화- 프로그램 설치 및 실행 명령    
    void Ending();//시뮬레이션 종료
};

Scheduler.cpp

//Scheduler.h
#include "Scheduler.h"

Scheduler::Scheduler()
{
    Init();    
}
void Scheduler::Init()
{
    //하드디스크에 프로그램 설치를 표현
    hard_disk.push_back(new EHProcess("A",20,5));
    hard_disk.push_back(new EHProcess("B",23,6));
    hard_disk.push_back(new EHProcess("C",18,4));
    miter seek = hard_disk.begin();
    miter end = hard_disk.end();
    EHProcess *pro=0;    //하드디스크에 설치한 프로그램을 실행 명령을 표현
    for( ; seek != end ; ++seek)
    {
        pro = *seek;
        rq.push(pro); //대기 큐에서 기다림
        pro->IdleToReady();//Idle 상태에서 Ready상태로 전이
    }
}

Scheduler::~Scheduler()
{
    Ending();
}
void Scheduler::Ending()
{
    miter seek = hard_disk.begin();
    for(   ; seek != hard_disk.end(); ++seek)
    {
        delete (*seek); 
    }
}

void Scheduler::Simulation()
{
    EHProcess *process = 0;
    int job=0;
    while( !rq.empty() ) //대기 큐가 비어있지 않을 때
    {        
        process = rq.front();//가장 먼저 대기한 프로세스를 꺼냄
        rq.pop();

        job = process->Running();//꺼낸 프로세스를 실행
        if(job) //남은 작업이 있다면
        {
            rq.push(process); //대기큐에서 기다림
        }
        else
        {
            process->EndProgram();//프로세스 종료
        }
    }
}

Program.cpp

//Program.cpp
#include "Scheduler.h"
#include 
int main()
{
    Scheduler *sch = new Scheduler;    
    sch->Simulation();
    delete sch;    
    return 0;
}

실행 결과

A 총 작업량:20 CPU 점유시 작업량:5
B 총 작업량:23 CPU 점유시 작업량:6
C 총 작업량:18 CPU 점유시 작업량:4
A CPU 점유
20 19 18 17 16 
B CPU 점유
23 22 21 20 19 18 
C CPU 점유
18 17 16 15 
A CPU 점유
15 14 13 12 11 
B CPU 점유
17 16 15 14 13 12 
C CPU 점유
14 13 12 11 
A CPU 점유
10 9 8 7 6 
B CPU 점유
11 10 9 8 7 6 
C CPU 점유
10 9 8 7 
A CPU 점유
5 4 3 2 1 
A종료
B CPU 점유
5 4 3 2 1 
B종료
C CPU 점유
6 5 4 3 
C CPU 점유
2 1 
C종료

언제나휴일 여행 및 산책

독립기념관

파서 트리를 이용한 계산기 [C++]

언휴 — Wed, 8 Jan 2025 15:30:13 +0900

파서 트리를 이용한 계산기 [C++] Part1

파서 트리를 이용한 계산기 [C++] Part2

안녕하세요. 언제나 휴일에 언휴예요.

이번에는 파서 트리를 이용한 계산기를 구현하는 실습이예요.

23+8*9-7 과 같은 수식을 계산하면 8*9를 먼저 계산하고 23+(8*9)-7 순으로 계산합니다.

이처럼 수식을 연산자 우선 순위에 맞게 계산하기 위해 여기에서는 파서 트리를 이용할 거예요.

파서 트리를 이용한 계산기에 관한 이론적인 내용은 자료구조와 알고리즘 C++ 9.3 수식 파서 트리를 참고하세요.

#include 
#include 
using namespace std;
class Calculator
{
    string expr;
public:
    Calculator(string expr)
    {        
        this->expr = expr;
        tcnt = 0;
    }
    void Run()
    {
        cout<<expr<<"을 계산합니다. ..."<<endl;
        if(Lexical())
        {
            if(Syntax())
            {
                Parsing();
                PostOrderView();
                cout<<expr<<"="<<Calculate()<<endl;
            }
            else
            {
                cout<<"수식에 사용한 표현이 문법에 맞지 않습니다."<<endl;
            }
        }
        else
        {
            cout<<"사용할 수 없는 기호가 있습니다."<<endl;
        }
        cout<<endl;
    }
private:
    bool Lexical()
    {        
        int i = 0;
        while(expr[i])
        {
            if(IsOperator(expr[i]))
            {
                i = MakeOperator(i);
            }
            else
            {
                if(IsDigit(expr[i]))
                {
                    i = MakeOperand(i);
                }
                else
                {
                    return false;
                }
            }
        }
        return true;
    }
    bool IsOperator(char ch)
    {
        return (ch =='+')||(ch=='-')||(ch=='*')||(ch=='/');
    }
    bool IsDigit(char ch)
    {
        return (ch>='0')&&(ch<='9');
    }
    struct Token
    {
        int priority;
        virtual void View()=0;
        bool MoreThanPriority(Token *token)
        {
            return priority>=token->priority;
        }
    };
    struct Operator:public Token
    {
        char ch;
        Operator(char ch)
        {
            this->ch = ch;
            if((ch=='+')||(ch=='-'))
            {
                priority = 1;
            }
            else
            {
                priority = 2;
            }
        }
        void View()
        {
            cout<<ch<<" ";
        }
        
    };
    Token *tokens[100];
    int tcnt;
    int MakeOperator(int i)
    {
        tokens[tcnt] = new Operator(expr[i]);
        tcnt++;
        return i+1;
    }
    struct Operand:public Token
    {
        int value;
        Operand(int value)
        {
            this->value = value;
            priority = 3;            
        }
        void View()
        {
            cout<<value<<" ";
        }
        
    };
    
    int MakeOperand(int i)
    {
        int value = 0;
        while(IsDigit(expr[i]))
        {
            value = value*10 + expr[i] - '0';
            i++;
        }
        tokens[tcnt] = new Operand(value);
        tcnt++;
        return i;
    }    

    bool Syntax()
    {
        if(tcnt%2==0)
        {
            return false;
        }
        if(tokens[0]->priority !=3)
        {
            return false;
        }
        for(int i = 1; i<tcnt; i+=2)
        {
            if(tokens[i]->priority==3)
            {
                return false;
            }            
            if(tokens[i+1]->priority != 3)
            {
                return false;
            }
        }
        return true;
    }

    struct ParserTree
    {
        struct Node
        {
            Token *token;
            Node *lc;
            Node *rc;
            Node(Token *token)
            {
                this->token = token;
                lc = rc = 0;
            }
        };
        Node *root;
        ParserTree(Token *token)
        {
            root = new Node(token);
        }
        void Add(Token *token)
        {
            Node *now = new Node(token);
            Token *st = root->token;
            if(st->MoreThanPriority(token))
            {
                now->lc = root;
                root = now;
            }
            else
            {
                if(token->priority !=3)
                {
                    now->lc = root->rc;
                    root->rc = now;
                }
                else
                {
                    Node *pa = root;
                    while(pa->rc)
                    {
                        pa = pa->rc;
                    }
                    pa->rc = now;
                }
            }
        }
        void View()
        {
            PostOrder(root);
            cout<<endl;
        }
        void PostOrder(Node *sr)
        {
            if(sr)
            {
                PostOrder(sr->lc);
                PostOrder(sr->rc);
                sr->token->View();
            }
        }
        int Calculate()
        {
            return PostOrderCalculate(root);
        }
        int PostOrderCalculate(Node *sr)
        {
            if(sr->lc)
            {
                int lvalue = PostOrderCalculate(sr->lc);
                int rvalue = PostOrderCalculate(sr->rc);
                Operator *op = dynamic_cast(sr->token);
                switch(op->ch)
                {
                case '+': return lvalue + rvalue;
                case '-': return lvalue - rvalue;
                case '*': return lvalue * rvalue;
                case '/': 
                    if(rvalue)
                    {
                        return lvalue / rvalue;
                    }
                    cout<<"divide zero error"<<endl;
                    return 0;
                }
                throw "정의하지 않은 연산자입니다.";
            }
            Operand *op = dynamic_cast(sr->token);
            return op->value;
        }
    };
    ParserTree *ps;
    void Parsing()
    {
        ps = new ParserTree(tokens[0]);
        for(int i = 1; i<tcnt;i++)
        {
            ps->Add(tokens[i]);
        }
    }
    void PostOrderView()
    {
        ps->View();
    }
    int Calculate()
    {
        return ps->Calculate();        
    }
};

int main()
{
    string tc_exprs[6]=
    {
        "2+3-5*5+6/2",
        "23*5/2+4*6",
        "2+4*5#6",
        "2+3*5+",
        "3+36+-7",
        "45+3*5-2+5/2*7",        
    };
    for(int i = 0; i<6; i++)
    {
        Calculator *cal  = new Calculator(tc_exprs[i]);
        cal->Run();
        delete cal;
    }
    return 0;
}

언제나휴일 여행 및 산책

독립기념관

함수 개체, 회원 및 회원 컬렉션 구현[C++]

언휴 — Wed, 8 Jan 2025 15:00:36 +0900

함수 개체, 회원 및 회원 컬렉션 구현[C++]

안녕하세요. 언제나 휴일에 언휴예요.

이번에는 함수 개체 실습이예요.

함수 개체는 특정 형식 개체를 함수처럼 호출 가능한 개체를 말합니다.

이를 위해 해당 형식에는 함수 호출 연산자를 중복 정의합니다.

이 외에도 이번 실습에는 개체 출력자, 인덱스 연산자 중복 정의를 구현하는 부분도 있습니다.

다음은 함수 호출 연산자를 중복 정의한 간단한 예제입니다.

class FunObject
{
public:
    int operator()(int a, int b)
    {
        return a + b;
    }
};
int main()
{
    FunObject fobj;
    int re = fobj(3,4);
    cout << "결과:" << re << endl;
    return 0;
}

위 예에서 FunObject 클래스에는 함수 호출 연산자를 중복 정의하고 있습니다.

그리고 FunObject 형식 변수 fobj 를 함수 처럼 호출하는 것을 볼 수 있습니다.

이번 실습에서는 회원 클래스를 정의하고 회원 클래스를 보관하는 회원 컬렉션을 구현할 거예요.

회원 컬렉션 형식에는 특정 조건을 만족하는 회원 개체를 반환하는 메서드(FindIf)를 제공할 거예요.

그리고 해당 메서드의 입력 인자로 특정 조건을 만족하는지 판별하는 알고리즘을 정의한 함수 개체를 전달 받을 거예요.

다음은 실습 소스 코드입니다.

/* https://ehpub.co.kr
   C++ 예제 - 언제나 휴일
   함수 개체 - 회원 컬렉션
   연산자 중복 정의 및 개체 출력자 포함
*/
#include 
#include 
using namespace std;

class Member
{
    int num;
    string name;
public:
    Member(int num, string name)
    {
        this->num = num;
        this->name = name;
    }
    int GetNum()const
    {
        return num;
    }
    string GetName()const
    {
        return name;
    }
};

ostream& operator<<(ostream& os, const Member* data)
{
    os << "번호:" << data->GetNum() << " 이름:" << data->GetName();
    return os;
}

class IEqual
{
public:
    virtual bool operator()(Member* data) = 0;
};

class MemberCollection
{
    Member** base;
    const int capacity;
    int count;
public:
    MemberCollection(int capacity) :capacity(capacity)
    {
        base = new Member * [capacity];
        count = 0;
    }
    ~MemberCollection()
    {
        delete[] base;
    }
    bool PushBack(Member* data)
    {
        if (IsFull())
        {
            return false;
        }
        base[count] = data;
        count++;
        return true;
    }
    bool IsFull()const
    {
        return count == capacity;
    }
    bool IsAvailIndex(int index)const
    {
        return (index >= 0) && (index < capacity);
    }
    int GetCount()const
    {
        return count;
    }
    Member*& operator[](int index)
    {
        if (IsAvailIndex(index) == false)
        {
            throw "사용할 수 없는 인덱스";
        }
        return base[index];
    }
    Member* FindIf(IEqual& ie)
    {
        for (int i = 0; i < count; i++)
        {
            if (ie(base[i]))
            {
                return base[i];
            }
        }
        return NULL;
    }
};


class EqualNum :
    public IEqual
{
    int num;
public:
    EqualNum(int num)
    {
        this->num = num;
    }
    virtual bool operator()(Member* data)
    {
        return num == data->GetNum();
    }
};

int main()
{
    MemberCollection dc(100);
    dc.PushBack(new Member(3, "홍길동"));
    dc.PushBack(new Member(2, "강감찬"));
    dc.PushBack(new Member(6, "을지문덕"));
    dc.PushBack(new Member(7, "한석봉"));

    int count = dc.GetCount();
    for (int i = 0; i < count; i++)
    {
        cout << dc[i] << endl;
    }

    cout << "검색할 회원 번호:";
    int num;
    cin >> num;
    EqualNum en(num);
    Member* member = dc.FindIf(en);
    if (member != NULL)
    {
        cout << member << endl;
    }
    else
    {
        cout << "찾지 못하였음" << endl;
    }

    for (int i = 0; i < count; i++)
    {
        delete dc[i];
    }

    return 0;
}

언제나휴일 여행 및 산책

독립기념관

개체 출력자 실습 – 회원 클래스 및 쉬프트 연산자 중복 정의 [C++]

언휴 — Wed, 8 Jan 2025 14:30:17 +0900

개체 출력자 실습 – 회원 클래스 및 쉬프트 연산자 중복 정의 [C++]

안녕하세요. 언제나 휴일에 언휴예요.

이번 실습에서는 개체 출력자를 구현합니다.

C++에서 출력을 위해 ostream 형식을 정의하고 있어요. cout이 대표적인 ostream 형식 개체죠.

개체 출력자는 ostream 형식 개체를 이용하여 개체 정보를 출력할 수 있게 정의하는 코드 집합을 개체 출력자라 부릅니다.

이번 실습에서는 회원 클래스를 정의하고 개체 출력자를 정의할 거예요.

기본 형식처럼 회원 개체 정보를 ostream 형식 개체로 출력할 수 있게 구현하는 실습입니다.

/* https://ehpub.co.kr 
   C++ 예제 - 언제나 휴일
   개체 출력자 - 회원 클래스
*/
#include 
#include 
using namespace std;

class Member
{
    int num;
    string name;
public:
    Member(int num, string name)
    {
        this->num = num;
        this->name = name;
    }
    int GetNum()const
    {
        return num;
    }
    string GetName()const
    {
        return name;
    }
    void View(ostream& os = cout)const
    {
        os << "번호:" << num << " 이름:" << name;
    }

};
ostream &operator<<(ostream& os, const Member& member)
{
    member.View(os);
    return os;
}
ostream& operator<<(ostream& os, const Member* member)
{
    member->View(os);
    return os;
}
int main()
{    
    Member member(3, "홍길동");
    Member *member2 = new Member(2, "강감찬");
    
    cout << member << endl;
    cout << member2 << endl;

    delete member2;
    return 0;
}

실행 결과는 다음과 같습니다.

번호:3 이름:홍길동
번호:2 이름:강감찬

언제나휴일 여행 및 산책

독립기념관

다형성 실습 – 오케스트라, 음악가, 피아니스트, 드러머 [C++]

언휴 — Wed, 8 Jan 2025 14:00:52 +0900

다형성 실습 – 오케스트라, 음악가, 피아니스트, 드러머 [C++]

안녕하세요. 언제나 휴일에 언휴예요.

이번에는 다형성 실습이예요.

다형성은 하나의 이름으로 보여도 실제 형태는 다양할 수 있는 성질입니다.

기반 형식 포인터 변수로 파생 형식 개체를 사용할 수 있는 특징을 형식의 다형성이라고 부릅니다.

기반 형식의 가상 메서드를 파생 형식에서 재정의할 수 있습니다.

이 때 기반 형식 포인터 변수로 해당 메서드를 호출하면 실제 개체 형식에 정의한 메서드가 동작합니다.

이러한 특징을 메서드의 다형성이라고 부릅니다.

이러한 다형성에 관한 실습을 오케스트라(음악가, 피아니스트, 드러머) 소재로 진행합니다.

/* https://ehpub.co.kr
   C++ 예제 - 언제나 휴일
   다형성 실습
*/
#include 
using namespace std;

class Musician
{
    const int mnum;
public:
    Musician(int mnum) :mnum(mnum)
    {
    }
    void Greeting()
    {
        cout << mnum << " 인사합니다." << endl;
    }
    virtual void Play() = 0;//추상 메서드(순수 가상 메서드)
    int GetMNum()const
    {
        return mnum;
    }
};
class Pianist :
    public Musician
{
public:
    Pianist(int mnum) :Musician(mnum)
    {

    }
    virtual void Play()
    {
        cout << GetMNum() << " 딩동 댕동~" << endl;
    }
}; 
class Drummer :
    public Musician
{
public:
    Drummer(int mnum) :Musician(mnum)
    {

    }
    virtual void Play()
    {
        cout << GetMNum() << " 두두둥" << endl;
    }
};
class Orchestra
{
    Musician** members;
    const int max_member;
    int now_members;
public:
    Orchestra(int max_member) :max_member(max_member)
    {
        Initialize();
    }    
    ~Orchestra()
    {
        delete[] members;
    }
    bool JoinMember(Musician* mu)
    {
        if (now_members == max_member)
        {
            return false;
        }
        members[now_members] = mu;
        now_members++;
        return true;
    }
    void Greeting()const
    {
        cout << "저희 단원을 소개합니다. 멤버는 총 " << now_members << "명 입니다." << endl;
        for (int i = 0; i < now_members; i++)
        {
            members[i]->Greeting();
        }
    }
    void StartConcert()
    {
        for (int i = 0; i < now_members; i++)
        {
            members[i]->Play();//메서드의 다형성
        }
    }
private:
    void Initialize()
    {
        members = new Musician * [max_member];
        now_members = 0;
    }

};
int main()
{
    Orchestra* orchestra = new Orchestra(50);
    Pianist* pianist = new Pianist(1);
    Drummer* drummer = new Drummer(2);
    orchestra->JoinMember(pianist);//형식의 다형성
    orchestra->JoinMember(drummer);//형식의 다형성
    orchestra->Greeting();
    orchestra->StartConcert();
    delete orchestra;
    delete drummer;
    delete pianist;

    return 0;
}

다음은 실행 결과입니다.

저희 단원을 소개합니다. 멤버는 총 2명 입니다.
1 인사합니다.
2 인사합니다.
1 딩동 댕동~
2 두두둥

언제나휴일 여행 및 산책

독립기념관

상품과 할인 상품 – 상속 실습 [C++]

언휴 — Wed, 8 Jan 2025 13:30:26 +0900

상품과 할인 상품 – 상속 실습 [C++]

안녕하세요. 언제나 휴일에 언휴예요.

이번에는 상속 실습을 해 볼 거예요.

실습 소재는 상품과 할인 상품 클래스를 정의합니다.

상품과 할인 상품 클래스 다이어그램

클래스 다이어그램에서 삼각형과 실선으로 표현하는 관계를 일반화 관계라고 불러요.

일반화 관계는 기반 형식(Product)과 파생 형식(Discount Product) 사이의 관계입니다.

일반화 관계에서 파생 형식은 기반 형식의 멤버를 상속받는 특징을 갖습니다.

/* https://ehpub.co.kr
   C++ 예제 - 언제나 휴일
   상속 실습 - 상품과 할인 상품 클래스 정의하기
*/
#include 
#include 
using namespace std;
class Product
{
    string name;
    int price;
public:
    Product(string name, int price)
    {
        SetName(name);
        SetPrice(price);
    }
    virtual int GetPrice()const
    {
        return price;
    }
    string GetName()const
    {
        return name;
    }
    virtual void Print()const
    {
        cout << name << " 판매 가격:" << GetPrice() << endl;
    }
private:
    void SetPrice(int price)
    {
        this->price = price;
    }
    void SetName(string name)
    {
        this-> name = name;
    }
};

class DiscountProduct :public Product
{
    int discount;
public:
    DiscountProduct(string name, int price, int discount):Product(name,price)
    {
        SetDiscount(discount);
    }
    int GetDiscount()const
    {
        return discount;
    }
    virtual int GetPrice()const
    {
        int origin_price = Product::GetPrice();
        int dc = origin_price * discount / 100;
        return origin_price - dc;
    }
    virtual void Print()const
    {
        cout << "상품 가격:" << Product::GetPrice() << " 할인율:" << discount << " ";
        Product::Print();
    }
private:
    void SetDiscount(int discount)
    {
        this->discount = discount;
    }
};
int main()
{
    Product* p1 = new Product("치약", 3000);
    Product* p2 = new DiscountProduct("칫솔", 3000, 15);
    p1->Print();
    p2->Print();
    delete p1;
    delete p2;
    return 0;
}

언제나휴일 여행 및 산책

독립기념관

회원 클래스 정의 – 정적 멤버 캡슐화 [C++]

언휴 — Wed, 8 Jan 2025 13:00:26 +0900

회원 클래스 정의 – 정적 멤버 캡슐화 [C++]

안녕하세요. 언제나 휴일에 언휴예요.

이번 예제는 정적 멤버 캡슐화를 다룰 거예요.

실습은 회원 클래스를 정의합니다.

회원 실습 클래스 다이어그램

클래스 다이어그램에서 밑줄로 표시한 멤버가 정적 멤버입니다.

가장 최근에 부여한 회원 번호(lastnum)과 현재까지 생성한 회원 수를 반환하는 메세드(GetMemberCount)를 캡슐화할 거예요.

이 두 개의 멤버는 개체의 멤버가 아닌 형식의 멤버로 형식 이름으로 접근할 수 있어요.

/* https://ehpub.co.kr
   C++ 예제 - 언제나 휴일
   회원 클래스 정의 - 정적 멤버 필드 캡슐화
*/
#include 
#include 
using namespace std;
class Member
{
    static int last_num;
    const int num;
    string name;
public:
    static int GetMemberCount()
    {
        return last_num;
    }
    Member(string name) :num(++last_num)
    {
        this->name = name;
    }
    int GetNum()const
    {
        return num;
    }
    string GetName()const
    {
        return name;
    }
    virtual string ToString()const
    {
        char buf[256] = "";
        sprintf_s(buf, sizeof(buf), "번호:%04d 이름:%s", num, name.c_str());
        return buf;
    }
    bool IsEqual(int num)const
    {
        return this->num == num;
    }
    bool IsEqual(string name)const
    {
        return this->name == name;
    }
};

int Member::last_num;

int main()
{
    Member* marr[3];
    //회원 개체 생성
    marr[0] = new Member("홍길동");
    marr[1] = new Member("강감찬");
    marr[2] = new Member("이순신");
    //회원 목록 출력
    cout << "현재 회원 수:" << Member::GetMemberCount() << endl;
    for (int i = 0; i < 3; i++)
    {
        cout << marr[i]->ToString() << endl;
    }
    //회원 이름 검색
    string name;
    cout << "검색할 이름:";
    cin >> name;
    bool check = false;
    for (int i = 0; i < 3; i++)
    {
        if (marr[i]->IsEqual(name))
        {
            cout << marr[i]->ToString() << endl;
            check = true;
        }
    }
    if (check == false)
    {
        cout << "없습니다." << endl;
    }
    //회원 번호 검색
    int num;
    cout << "검색할 번호:";
    cin >> num;
    int i;
    for (i = 0; i < 3; i++)
    {
        if (marr[i]->IsEqual(num))
        {
            cout << marr[i]->ToString() << endl;
            break;
        }
    }
    if (i == 3)
    {
        cout << "없습니다." << endl;
    }
    //회원 개체 소멸
    for (int i = 0; i < 3; i++)
    {
        delete marr[i];
    }
    return 0;
}

언제나휴일 여행 및 산책

독립기념관

복소수 클래스 정의 – 캡슐화 실습 [C++]

언휴 — Wed, 8 Jan 2025 12:30:44 +0900

복소수 클래스 정의 – 캡슐화 실습 [C++]

안녕하세요. 언제나 휴일에 언휴예요.

이번 강의는 캡슐화 실습으로 복소수 클래스를 정의할 거예요. 실수부와 허수부를 멤버 필드로 갖고 있습니다. 그리고 실수부와 허수부의 값을 접근하는 접근자 메서드와 설정하는 설정자 메서드를 갖습니다. 마지막으로 복소수 개체 정보를 문자열로 반환하는 메서드를 멤버로 갖습니다.

복소수 클래스 다이어그램

#include 
#include 
using namespace std;

class Complex
{
    double image;
    double real;
public:
    Complex(double real = 0, double image = 0)
    {
        SetReal(real);
        SetImage(image);
    }
    void SetReal(double value)
    {
        real = value;
    }
    void SetImage(double value)
    {
        image = value;
    }
    double GetReal()const
    {
        return real;
    }
    double GetImage()const
    {
        return image;
    }
    string ToString()const
    {
        char buf[256] = "";
        if ((real != 0) && (image != 0))
        {
            if (image > 0)
            {
                sprintf_s(buf, sizeof(buf), "%g+%gi", real, image);
            }
            else
            {
                sprintf_s(buf, sizeof(buf), "%g%gi", real, image);
            }
            return buf;
        }
        if (real != 0)
        {
            sprintf_s(buf, sizeof(buf), "%g", real);
            return buf;
        }
        if (image != 0)
        {
            sprintf_s(buf, sizeof(buf), "%gi", image);
            return buf;
        }
        return "0";
    }
};

int main(void)
{
    Complex c1;
    Complex c2(2.1);
    Complex c3(2.1,3.3);
    Complex c4(0, 3.3);
    Complex c5(2.1, 0);
    Complex c6(2.1, -3.3);

    cout << "c1:" << c1.ToString() <<endl;
    cout << "c2:" << c2.ToString() << endl;
    cout << "c3:" << c3.ToString() << endl;
    cout << "c4:" << c4.ToString() << endl;
    cout << "c5:" << c5.ToString() << endl;
    cout << "c6:" << c6.ToString() << endl;
    return 0;
}

다음은 실행 결과입니다.

c1:0
c2:2.1
c3:2.1+3.3i
c4:3.3i
c5:2.1
c6:2.1-3.3i

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#] CSV 파일 입출력 – StreamReader 클래스 및 StreamWriter 클래스 사용

언휴 — Wed, 8 Jan 2025 12:00:53 +0900

CSV 파일 입출력 – StreamReader 클래스 및 StreamWriter 클래스 사용

안녕하세요. 언제나 휴일에 언휴예요.

이번 강의에서는 데이터 분석에서 많이 사용하는 “CSV” 포멧의 파일 입출력을 알아볼게요.

CSV 파일은 데이터를 콤마를 기준으로 열거합니다.

이를 엑셀 등의 프로그램으로 보면 테이블 형태로 확인할 수가 있죠.

여러분들이 CSV 파일 포멧으로 데이터를 기록할 때 주의할 점은 데이터 내용에 콤마가 있다면 다른 문자로 변경한 후에 저장하세요. 만약 이를 유지하길 원한다면 다른 포멧의 파일 입출력을 선택하세요.

실습은 동영상 강의와 소스 코드를 참고하세요.

이번 실습에서는 StreamReader 클래스와 StreamWtirer 클래스를 이용하여 입출력합니다.

Book.cs

namespace StreamReader를_이용한_CSV_포멧_파일_입출력
{
    public class Book
    {
        public string Title
        {
            get;
            private set;
        }
        public string Desc
        {
            get;
            private set;
        }
        public string Author
        {
            get;
            private set;
        }
        public Book(string title,string desc,string author)
        {
            Title = title;
            Desc = desc;
            Author = author;
        }
        public override string ToString()
        {
            return Title;
        }
    }
}

BookManager.cs

using System.Collections;
using System.Collections.Generic;
using System.IO;

namespace StreamReader를_이용한_CSV_포멧_파일_입출력
{
    public class BookManager: IEnumerable
    {
        List books = new List();
        public void Add(string title, string desc,string author)
        {
            title = title.Replace(",", " ");
            desc = desc.Replace(",", " ");
            author = author.Replace(",", " ");
            books.Add(new Book(title, desc, author));
        }
        public void Save()
        {
            FileStream fs = File.Create("book.csv");
            StreamWriter sw = new StreamWriter(fs);
            foreach (Book book in books)
            {
                sw.WriteLine("{0},{1},{2}", book.Title, book.Desc, book.Author);
            }
            sw.Close();
            fs.Close();

        }
        public void Load()
        {
            FileStream fs = File.OpenRead("book.csv");
            StreamReader sr = new StreamReader(fs);
            string s;
            string[] sitems;
            while(sr.EndOfStream==false)
            {
                s = sr.ReadLine();
                sitems = s.Split(',');
                books.Add(new Book(sitems[0], sitems[1], sitems[2]));
            }
            sr.Close();
            fs.Close();
        }

        public IEnumerator GetEnumerator()
        {
            return books.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return books.GetEnumerator();
        }
    }
}

Program.cs

/* https://ehpub.co.kr
 * CSV 포멧 파일 입출력
 * StreamReader, StreamWriter 이용 */
using System;

namespace StreamReader를_이용한_CSV_포멧_파일_입출력
{
    class Program
    {
        static void Main(string[] args)
        {
            BookManager bm = new BookManager();
            bm.Add("ABC,123", "알파벳과 숫자에 관하여 설명하는 도서", "알번");
            bm.Add("안녕하세요,123", "테스트 프로그램입니다. 그리고, 테스트입니다.", "알번");
            bm.Add("디딤돌", "알파벳과 숫자에 관하여 설명하는 도서", "알번");
            bm.Add("실습으로 다지는", "알파벳과 숫자에 관하여 설명하는 도서", "알번");
            bm.Save();

            BookManager bm2 = new BookManager();
            bm2.Load();
            foreach(Book book in bm2)
            {
                Console.WriteLine("{0}, {1},{2}", book.Title, book.Desc, book.Author);
            }
        }
    }
}

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#] 런타임에 라이브러리 로딩하여 사용하기 – .NET 리플렉션

언휴 — Wed, 8 Jan 2025 11:30:36 +0900

런타임에 라이브러리 로딩하여 사용하기 – .NET 리플렉션

안녕하세요. 언제나 휴일에 언휴예요.

1. 런타임에 라이브러리 로딩? 리플렉션!

이번 실습은 프로그램이 동작하는 런타임에 라이브러리를 로딩하여 사용하는 것을 해 볼 거예요.

.NET에서는 리플렉션이라는 기술을 제공하고 있으며 이를 이용하여 런타임에 라이브러리를 로딩하여 사용합니다.

런타임에 라이브러리를 로딩하여 사용한다는 것은 무슨 의미일까요?

예를 들어 미디어 플레이어 응용과 코덱 라이브러리는 배포자가 다를 수 있습니다.

미디어 플레이어 응용에서 미디어를 선택하여 재생 버튼을 누르면 미디어의 압축 형태에 맞는 코덱 라이브러리를 로딩하여 재생합니다.

만약 코덱 라이브러리가 없으면 코덱이 없다고 메시지 창을 띄워줍니다.

이처럼 동작하려면 미디어 플레이어 응용은 코덱을 참조하여 구현하는 것이 아니라 명시적으로 로딩하여 사용하게 구현해야 합니다.

만약 참조하여 구현하면 응용이 시작할 때 해당 라이브러리가 없으면 예외를 발생하여 프로그램은 종료합니다.

테스트 할 라이브러리를 만들고 참조 추가하지 마세요.

만든 라이브러리 파일을 명시적 어셈블리 로딩할 프로그램 실행 파일이 있는 곳으로 복사하세요.

2. 라이브러리 소스 코드

using System;

namespace DemoLib
{
    public class Demo
    {
        int num;
        public int Num
        {
            get
            {
                return num;
            }
        }
        public int Add(int a,int b)
        {
            Console.WriteLine("Add 메서드 호출 됨:{0},{1}", a, b);
            return a + b;
        }
        public Demo(int n)
        {
            Console.WriteLine("Demo 생성자 호출됨:{0}", n);
            num = n;
        }
        public static void Foo(string msg)
        {
            Console.WriteLine("Foo 메서드 호출됨:{0}", msg);
        }
    }
}

3. 명시적으로 라이브러리 로딩 예제

/* https://ehpub.co.kr
 * Reflection
 * 명시적 어셈블리 로딩                                                                                             
 */

using System;
using System.Reflection;

namespace 닷넷_리플렉션___명시적_어셈블리_로딩하여_사용하기
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Assembly asm = Assembly.Load("DemoLib");
                //Type[] types = asm.GetTypes();
                //foreach(Type type in types)
                //{
                //    Console.WriteLine(type);
                //}
                Type type = asm.GetType("DemoLib.Demo");
                object[] objs = new object[] { 5 };
                object demo_ins = Activator.CreateInstance(type,objs);

                PropertyInfo pi = type.GetProperty("Num");
                int num = (int)pi.GetValue(demo_ins);
                Console.WriteLine("번호:{0}", num);

                MethodInfo mi = type.GetMethod("Add");
                objs = new object[] { 3, 7 };
                int re = (int)mi.Invoke(demo_ins, objs);
                Console.WriteLine("반환:{0}", re);

                mi = type.GetMethod("Foo");
                objs = new object[] { "헬로우" };
                mi.Invoke(null, objs);
                
                Console.WriteLine("테스트 종료");
            }
            catch(Exception ex)
            {
                Console.WriteLine("예외 발생");
            }
        }
    }
}

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#] 학생 키우기 – 학생 구현 및 제어

언휴 — Wed, 8 Jan 2025 11:00:53 +0900

[실습으로 다지는 C#] 학생 키우기 – 학생 구현 및 제어

안녕하세요. 언제나 휴일, 언휴예요.

이번 실습할 시나리오는 학생 개체 1명을 생성한 후에 메뉴를 통해 제어하는 프로그램입니다.

다음은 실습 시나리오입니다.

초기화(Init)
    학생 개체 생성(1명)
사용자와 상호작용(Run)
    F1: 공부하기
    F2: 강의받기
    F3: 잠자기
    F4: 휴식하기
    F5: 음료마시기
    F6: 노래하기
    F7: 학생 상태 출력

다음은 정의할 학생 클래스 다이어그램입니다.

실습할 학생 클래스 다이어그램

학생 형식의 멤버 필드입니다.

pn: 주민번호(순차부여)
name: 이름(생성 시 전달)
iq: 아이큐(0~200, 초기 100)
hp: 체력(0~200, 초기 100)
stress: 스트레스(0~100, 초기 0)
scnt: 연속으로 공부한 횟수(0~5)
     "공부하다.", "강의받다"를 할 때는 1 증가, 기타 행동할 때는 0으로 리셋
lastpn: 가장 최근에 부여한 주민번호(정적 멤버)
각 멤버 필드 값 가져오기 블록 제공(속성)

학생 클래스의 메서드입니다. 메서드 이름 뒤의 값은 각 행동을 했을 때 변화하는 수치들입니다.

생성자(이름)
Study: 체력 -5, 아이큐 scnt, 스트레스 2 
ListenLecture: 체력 3, 아이큐 scnt, 스트레스 scnt
Sleep: 체력 10, 스트레스 -5
Relax : 체력 3, 스트레스 -25
Drink : 체력 5, 지력 -10 , 스트레스 2
Sing : 체력 10, 지력 scnt-5, 스트레스 5-scnt

학생의 체력, 아이큐, 스트레스, 연속으로 공부한 횟수는 정해진 값이죠. 이러한 값들은 상수 멤버로 정의하세요. 여기에서는 별도의 정적 클래스를 정의하기로 할게요.

namespace 학생_키우기_Part1.학생_제어
{
    static class StuConst
    {
        internal const int MIN_IQ = 0;
        internal const int MAX_IQ = 200;
        internal const int DEF_IQ = 100;

        internal const int MIN_HP = 0;
        internal const int MAX_HP = 200;
        internal const int DEF_HP = 100;

        internal const int MIN_STRESS = 0;
        internal const int MAX_STRESS = 100;
        internal const int DEF_STRESS = 0;

        internal const int MAX_SCNT = 5;
    }
}

학생 클래스에서 pn은 변하지 않는 값이네요. 읽기 전용으로 표현합시다.

아이큐, 체력, 스트레스, 연속으로 공부한 횟수는 특정 범위 내에서 제어해야 합니다. 이를 위해 설정하는 부분에서의 로직이 필요하죠. 따라서 멤버 필드를 별도로 선언하고 대응하는 속성을 정의하세요. 물론 set 블록에서 약속한 범위 내에서 동작하게 구현하셔야 합니다.

가장 최근에 부여한 주민번호는 정적 멤버로 구현합니다.

여기까지 표현한다면 다음처럼 표현할 수 있을 거예요.

    class Student
    {
        readonly int pn;
        internal string Name
        {
            get;
            private set;
        }
        int iq;
        internal int IQ
        {
            get
            {
                return iq;
            }
            private set
            {
                if(value>StuConst.MAX_IQ)
                {
                    value = StuConst.MAX_IQ;
                }
                if(value<StuConst.MIN_IQ)
                {
                    value = StuConst.MIN_IQ;
                }
                iq = value;
            }
        }
        int hp;
        internal int HP
        {
            get
            {
                return hp;
            }
            private set
            {
                if(value > StuConst.MAX_HP)
                {
                    value = StuConst.MAX_HP;
                }
                if(value < StuConst.MIN_HP)
                {
                    value = StuConst.MIN_HP;
                }
                hp = value;
            }
        }
        int stress;
        internal int Stress
        {
            get
            {
                return stress;
            }
            private set
            {
                if(value > StuConst.MAX_STRESS)
                {
                    value = StuConst.MAX_STRESS;
                }
                if(value < StuConst.MIN_STRESS)
                {
                    value = StuConst.MIN_STRESS;
                }
                stress = value;
            }
        }
             
        int scnt;
        internal int SCnt
        {
            get
            {
                return scnt;
            }
            private set
            {
                if(value < StuConst.MAX_SCNT)
                {
                    scnt = value;
                }
            }
        }
        static int lastpn;
    }

이제 멤버 메서드에서는 속성을 통해 시나리오에 맞게 값을 변경하면 메서드 구현은 쉽게 할 수 있겠죠.

다음은 멤버 메서드까지 구현한 Student 클래스 소스 코드입니다.

using System;
namespace 학생_키우기_Part1.학생_제어
{
    class Student
    {
        readonly int pn;
        internal string Name
        {
            get;
            private set;
        }
        int iq;
        internal int IQ
        {
            get
            {
                return iq;
            }
            private set
            {
                if(value>StuConst.MAX_IQ)
                {
                    value = StuConst.MAX_IQ;
                }
                if(value<StuConst.MIN_IQ)
                {
                    value = StuConst.MIN_IQ;
                }
                iq = value;
            }
        }
        int hp;
        internal int HP
        {
            get
            {
                return hp;
            }
            private set
            {
                if(value > StuConst.MAX_HP)
                {
                    value = StuConst.MAX_HP;
                }
                if(value < StuConst.MIN_HP)
                {
                    value = StuConst.MIN_HP;
                }
                hp = value;
            }
        }
        int stress;
        internal int Stress
        {
            get
            {
                return stress;
            }
            private set
            {
                if(value > StuConst.MAX_STRESS)
                {
                    value = StuConst.MAX_STRESS;
                }
                if(value < StuConst.MIN_STRESS)
                {
                    value = StuConst.MIN_STRESS;
                }
                stress = value;
            }
        }
             
        int scnt;
        internal int SCnt
        {
            get
            {
                return scnt;
            }
            private set
            {
                if(value < StuConst.MAX_SCNT)
                {
                    scnt = value;
                }
            }
        }
        static int lastpn;
        internal Student(string name)
        {
            Name = name;
            lastpn++;
            pn = lastpn;
            IQ = StuConst.DEF_IQ;
            HP = StuConst.DEF_HP;
            Stress = StuConst.DEF_STRESS;
        }
        internal void Study()
        {
            HP -= 5;
            IQ += SCnt;
            Stress += 2;
            SCnt++;
        }
        internal void ListenLecture()
        {
            HP += 3;
            IQ += SCnt;
            Stress += SCnt;
            SCnt++;
        }
        internal void Sleep()
        {
            HP += 10;
            Stress -= 5;
            SCnt = 0;
        }
        internal void Relax()
        {
            HP += 3;
            Stress -= 25;
            SCnt = 0;
        }
        internal void Drink()
        {
            HP += 5;
            IQ -= 10;
            Stress += 2;
            SCnt = 0;
        }
        internal void Sing()
        {
            HP += 10;
            IQ += (SCnt - 5);
            Stress += (5 - SCnt);
            SCnt = 0;
        }
        public override string ToString()
        {
            return string.Format("{0}<{1}>", Name, pn);
        }
    }
}

사용자와 상호작용을 담당하는 Application 클래스를 작성하는 것은 이전 강의에서 다루었었죠. 다시 한 번 복습한다고 생각하시고 작성해 보세요.

using System;

namespace 학생_키우기_Part1.학생_제어
{
    class Application
    {
        #region 단일체
        internal static Application Singleton
        {
            get;
            private set;
        }
        static Application()
        {
            Singleton = new Application();
        }
        Application()
        {
        }
        #endregion 단일체


        Student student = null;
        internal void Init()
        {
            Console.WriteLine("학생 키우기 Part1 - 학생 제어");
            Console.WriteLine("생성할 학생 이름을 입력하세요.");
            Console.Write("이름:");
            string name = Console.ReadLine();
            student = new Student(name);
            Console.WriteLine("아무 키나 누르면 시작합니다.");
            Console.ReadKey(true);
        }

        internal void Run()
        {
            ConsoleKey key = ConsoleKey.NoName;
            while ((key = SelectMenu()) != ConsoleKey.Escape)//반복((키=메뉴 선택())!=종료키)
            {
                switch (key) //선택한 키에 따라
                {
                    case ConsoleKey.F1: Study(); break;
                    case ConsoleKey.F2: ListenLecture(); break;
                    case ConsoleKey.F3: Sleep(); break;
                    case ConsoleKey.F4: Relax(); break;
                    case ConsoleKey.F5: Drink(); break;
                    case ConsoleKey.F6: Sing(); break;
                    case ConsoleKey.F7: View(); break;
                    default: Console.WriteLine("잘못 선택하였습니다."); break;//다른 키: 잘못 선택한 것을 통보
                }
                Console.WriteLine("아무 키나 누르세요.");
                Console.ReadKey(true);//사용자가 결과 확인할 기회를 부여(아무 키나 누를 때까지 대기)
            }
        }

        private void View()
        {
            Console.WriteLine("===  {0}  ===", student);
            Console.WriteLine("IQ:{0} HP:{0} Stress:{2} SCNT:{3}", student.IQ, student.HP, student.Stress, student.SCnt);
        }

        private void Sing()
        {
            Console.WriteLine("{0} 노래하다.", student);
            student.Sing();
        }

        private void Drink()
        {
            Console.WriteLine("{0} 마시다.", student);
            student.Drink();
        }

        private void Relax()
        {
            Console.WriteLine("{0} 휴식하다.", student);
            student.Relax();
        }

        private void Sleep()
        {
            Console.WriteLine("{0} 잠자다.", student);
            student.Sleep();
        }

        private void ListenLecture()
        {
            Console.WriteLine("{0} 강의받다.", student);
            student.ListenLecture();
        }

        private void Study()
        {
            Console.WriteLine("{0} 공부하다.", student);
            student.Study();
        }

        private ConsoleKey SelectMenu()
        {
            Console.Clear();
            Console.WriteLine("학생 키우기 메뉴");
            Console.WriteLine("{0}:공부하기", ConsoleKey.F1);
            Console.WriteLine("{0}:강의받기", ConsoleKey.F2);
            Console.WriteLine("{0}:잠자기", ConsoleKey.F3);
            Console.WriteLine("{0}:휴식하기", ConsoleKey.F4);
            Console.WriteLine("{0}:마시기", ConsoleKey.F5);
            Console.WriteLine("{0}:노래하기", ConsoleKey.F6);
            Console.WriteLine("{0}:정보보기", ConsoleKey.F7);
            Console.WriteLine("종료를 원하시면 {0}를 누르세요.", ConsoleKey.Escape);
            return Console.ReadKey(true).Key;
        }
    }
}

//http://ehpub.co.kr
//학생 키우기 Part1. 학생 제어
namespace 학생_키우기_Part1.학생_제어
{
    class Program
    {
        static void Main(string[] args)
        {
            Application app = Application.Singleton;
            app.Init();
            app.Run();
        }
    }
}

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#] 콘솔 응용의 기본 제어 – 메뉴로 상호 작용

언휴 — Wed, 8 Jan 2025 10:30:41 +0900

이번 강의에서는 콘솔 응용에서 메뉴를 통해 프로그램의 흐름을 제어하는 실습을 해 볼 거예요.

콘솔 응용에서 사용자와 상호 작용을 담당하는 형식을 Application이라고 정의할게요.

class Application
{
}

Application 형식 개체는 하나만 존재하는 것이 맞겠죠. 단일체 패턴을 적용하기로 할게요.

생성자의 접근 지정을 디폴트 값(private)으로 정하여 클래스 외부에서 개체 생성을 하지 못하게 막습니다. 그리고 정적 멤버로 클래스 외부에서 정적 개체를 참조할 수 있게 가져오기 속성을 제공합니다. 단일체는 정적 생성자에서 만드는 것을 추천합니다. 정적 생성자는 해당 형식을 사용하기 전에 수행하고 단 한 번만 수행하는 것을 보장하기 때문에 단일체를 생성하는 위치로 적당합니다.

    class Application
    {
        #region 단일체
        internal static Application Singleton 
        {
            get;
            private set;
        }
        static Application()
        {
            Singleton = new Application(); 
        }
        Application()
        {

        }
        #endregion 단일체
    }

Application 개체에서는 초기화, 사용자와 상호 작용(실제 주요 프로그램 동작부), 해제화를 수행하는 세 개의 메서드를 외부 클래스에 제공할게요.

    class Application
    {
        ...중략...
        internal void Init()
        {
        }

        internal void Run()
        {
        }
        internal void Exit()
        {
        }
    }

이번 실습에서 초기화와 해제화에서는 할 것이 특별히 없습니다. 차후에 초기화에서 파일에서 정보를 로딩하는 부분과 해제화에서 저장하는 등의 작업을 추가할 수 있을 것입니다.

여기에서는 단순히 프로그램이 시작하고 끝난다는 것을 인지할 수 있는 정도의 작업만 추가하기로 할게요.

해제화(Exit) 메서드에서 사용자가 마지막으로 아무 키나 누르면 종료할 수 있게 할게요. 이 때 Console.ReadLine 메서드는 적절치 않습니다.

Console.ReadLine 메서드는 사용자로부터 정보를 입력받기 위한 메서드입니다. 따라서 입력 도중에 잘못 누른 것을 지울 수 있게 백스페이스 키를 제공합니다. 이는 입력이 끝났다는 의사 표현으로 엔터를 입력하게 하는 것이죠.

아무 키나 누르면 바로 반응하는 메서드는 Console.ReadKey입니다. 입력 인자로 bool 형식 인자를 하나 받습니다. 만약 true를 전달하면 키를 눌렀을 때 콘솔 화면에 출력하지 않고 false를 누르면 콘솔 화면에 누른 키를 보여줍니다.

여기에서는 단순히 흐름 제어를 위한 것이지 정보 입력을 위한 것이 아니므로 true를 전달할게요.

    class Application
    {
        ...중략...
        internal void Init()
        {
            Console.WriteLine("콘솔 응용의 기본 제어 - 메뉴로 상호 작용");
            Console.WriteLine("아무 키나 누르면 시작합니다.");
            Console.ReadKey(true);
        }

        internal void Run()
        {
        }
        internal void Exit()
        {
            Console.WriteLine("아무 키나 누르시면 프로그램을 종료합니다.");
            Console.ReadKey(true);
        }
    }

이제 사용자와 상호작용하에 프로그램 흐름을 제어할 Run 메서드를 작성합시다.

전체 흐름은 종료 키를 선택할 때까지 선택한 키에 따라 함수를 수행하는 것을 반복하는 것입니다.

  
    class Application
    {
        ...생략...

        internal void Run()
        {
            //반복((키=메뉴 선택())!=종료키)
            {
                //선택한 키에 따라
                {
                    //키1 일 때: 메서드1 수행
                    //키2 일 때: 메서드2 수행
                    //키3 일 때: 메서드3 수행
                    //키4 일 때: 메서드4 수행
                    //키15일 때: 메서드5 수행
                    //다른 키: 잘못 선택한 것을 통보
                }
                //사용자가 결과 확인할 기회를 부여(아무 키나 누를 때까지 대기)
            }
        }
        ...생략...
    }
}

사용자로부터 메뉴를 입력받을 때도 Console.ReadKey 메서드가 적절합니다. 다음은 메뉴 선택과 메서드1~메서드5까지 추가한 예제 코드입니다.

using System;

namespace 콘솔_응용_상호_작용_개요___메뉴
{    
    class Application
    {
        #region 단일체
        internal static Application Singleton
        {
            get;
            private set;
        }
        static Application()
        {
            Singleton = new Application(); 
        }
        Application()
        {
        }
        #endregion 단일체



        internal void Init()
        {
            Console.WriteLine("콘솔 응용의 기본 제어 - 메뉴로 상호 작용");
            Console.WriteLine("아무 키나 누르면 시작합니다.");
            Console.ReadKey(true);
        }

        internal void Run()
        {
            ConsoleKey key = ConsoleKey.NoName;
            while((key = SelectMenu())!= ConsoleKey.Escape)//반복((키=메뉴 선택())!=종료키)
            {
                switch(key) //선택한 키에 따라
                {
                    case ConsoleKey.F1: FunA(); break;//키1 일 때: 메서드1 수행
                    case ConsoleKey.F2: FunB(); break;//키2 일 때: 메서드2 수행
                    case ConsoleKey.F3: FunC(); break;//키3 일 때: 메서드3 수행
                    case ConsoleKey.F4: FunD(); break;//키4 일 때: 메서드4 수행
                    case ConsoleKey.F5: FunE(); break;//키15일 때: 메서드5 수행
                    default: Console.WriteLine("잘못 선택하였습니다."); break;//다른 키: 잘못 선택한 것을 통보
                }
                Console.WriteLine("아무 키나 누르세요.");
                Console.ReadKey(true);//사용자가 결과 확인할 기회를 부여(아무 키나 누를 때까지 대기)
            }
        }
        internal void Exit()
        {
            Console.WriteLine("아무 키나 누르시면 프로그램을 종료합니다.");
            Console.ReadKey(true);
        }

        private void FunE()
        {
            Console.WriteLine("FunE");
        }

        private void FunD()
        {
            Console.WriteLine("FunD");
        }

        private void FunC()
        {
            Console.WriteLine("FunC");
        }

        private void FunB()
        {
            Console.WriteLine("FunB");
        }

        private void FunA()
        {
            Console.WriteLine("FunA");
        }

        private ConsoleKey SelectMenu()
        {
            Console.Clear();
            Console.WriteLine("사용자와 상호 작용 개요 - 메뉴편");
            Console.WriteLine("{0}:FunA", ConsoleKey.F1);
            Console.WriteLine("{0}:FunB", ConsoleKey.F2);
            Console.WriteLine("{0}:FunC", ConsoleKey.F3);
            Console.WriteLine("{0}:FunD", ConsoleKey.F4);
            Console.WriteLine("{0}:FunE", ConsoleKey.F5);
            Console.WriteLine("종료를 원하시면 {0}를 누르세요.", ConsoleKey.Escape);
            return Console.ReadKey(true).Key;
        }
    }
}

진입점에서는 Application 단일체를 참조한 후 초기화, 상호 작용, 해제화 순으로 진행합니다.

//http://ehpub.co.kr
//실습으로 다지는 C#
//콘솔 응용 메뉴를 통한 상호 작용 개요
namespace 콘솔_응용_상호_작용_개요___메뉴
{
    class Program
    {
        static void Main(string[] args)
        {
            Application app = Application.Singleton;
            app.Init();
            app.Run();
            app.Exit();
        }
    }
}

언제나휴일 여행 및 산책

독립기념

[실습으로 다지는 C#] 콘솔 글자 색 바꾸기 – Windows API 함수 사용

언휴 — Wed, 8 Jan 2025 10:00:22 +0900

이번 강의는 콘솔 글자 색을 바꾸는 실습입니다.

별다른 알고리즘은 없고 필요한 몇 개의 기술을 사용할 거예요.

기술 사용 노하우를 들여다 보고 따라해 보는 것이라 크게 고민을 하실 필요는 없어요.

콘솔 색 바꾸기 실습 실행화면

콘솔의 글자 색을 바꾸기 위해 Windows API 함수를 사용할 수 있어요.

- 콘솔의 글자 색을 바꾸는 함수
WINBASEAPI BOOL WINAPI SetConsoleTextAttribute(_In_ HANDLE hConsoleOutput,_In_ WORD wAttributes);
    
- 표준 핸들을 얻어오는 함수
    WINBASEAPI HANDLE WINAPI GetStdHandle(_In_ DWORD nStdHandle);
    
- 표준 출력 핸들 상수
    #define STD_OUTPUT_HANDLE   ((DWORD)-11)

Windows API와 같은 Native 기술을 사용할 때 DllImport 어튜리뷰트를 이용하여 외부에 있다는 것을 선언해 주어야 합니다.

그리고 인자 형식이 BOOL, INT, DWORD 등은 int로 표현하세요.

WORD는 short 형식으로 표현하세요.

HANDLE이나 포인터 형식은 IntPtr로 표현하세요.

선언문에서 정적 멤버로 캡슐화하고 외부에 있는 것을 extern으로 나타냅니다.

[DllImport("Kernel32.dll")]
static extern int SetConsoleTextAttribute(IntPtr hConsoleOutput, short wAttributes);

[DllImport("Kernel32.dll")]
static extern IntPtr GetStdHandle(int nStdHandle);

매크로 상수는 const 멤버로 설정하세요.

여기에서 이러한 멤버들은 WrapAPI 클래스를 만들어서 래핑(Wrapping)할게요. 단순히 래핑 목적이라 정적 클래스로 정의하는 것을 권합니다. 그리고 외부에서 접근해서 사용할 수 있는 멤버 메서드를 만들어 위에 선언한 멤버를 사용할게요.

이를 표현한 전체 코드입니다. 참고로 콘솔에서 사용할 수 있는 0~15까지의 색상 값을 열거형으로 정의했어요.

using System;
using System.Runtime.InteropServices;

namespace Windows_API_활용하여_콘솔_글자색_바꾸기
{
    public enum ConTextColor { LACK, BLUE, GREEN, JADE, RED,
        PURPLE, YELLOW, WHITE, GRAY, LIGHT_BLUE, LIGHT_GREEN,
        LIGHT_JADE, LIGHT_RED, LIGHT_PURPLE,
        LIGHT_YELLOW, LIGHT_WHITE };

    public static class WrapAPI
    {
        [DllImport("Kernel32.dll")]
        static extern int SetConsoleTextAttribute(IntPtr hConsoleOutput, short wAttributes);

        [DllImport("Kernel32.dll")]
        static extern IntPtr GetStdHandle(int nStdHandle);

        const int STD_OUTPUT_HANDLE = -11;
        public static void SetConsoleTextColor(ConTextColor color)
        {
            IntPtr handle = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(handle, (short)color);
        }
    }
}

이제 래핑한 WrapAPI SetConsoleTextColor 정적 메서드를 사용하면 끝입니다.

//http://ehpub.co.kr
//실력으로 다지는 C#
//Windows API를 활용하여 콘솔 글자색 바꾸기

using System;
namespace Windows_API_활용하여_콘솔_글자색_바꾸기
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadKey();
            WrapAPI.SetConsoleTextColor(ConTextColor.GREEN);
            Console.WriteLine("언제나 휴일");
            Console.ReadKey();
            WrapAPI.SetConsoleTextColor(ConTextColor.WHITE);
            Console.WriteLine("실습으로 다지는 C#");
            Console.ReadKey();
            WrapAPI.SetConsoleTextColor(ConTextColor.LIGHT_PURPLE);
            Console.WriteLine("http://ehpub.co.kr");
            Console.ReadKey();
            WrapAPI.SetConsoleTextColor(ConTextColor.WHITE);
        }
    }
}

낯선 기술을 사용하는 것은 두려울 수도 있지만 즐길 수 있다면 웃음을 줄 수도 있어요.

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#]택배 요금 계산 시뮬레이션

언휴 — Wed, 8 Jan 2025 09:30:59 +0900

[실습으로 다지는 C#]택배 요금 계산 시뮬레이션

이번 강의에서는 택배 요금을 계산하는 시뮬레이션을 만들어 봅시다.

택배 요금 실습 클래스 다이어그램

City, Parcel, Application 세 개의 클래스로 구성하고 있습니다.

City 클래스는 도시 이름과 (기준 도시에서) 상대적 거리를 멤버로 갖습니다. 그리고 다른 도시와의 거리를 계산하는 메서드를 제공합니다.

Parcel 클래스는 기준 요금과 무게를 멤버로 갖고 요금을 계산하는 메서드를 제공합니다.

Application은 택배 시스템 시뮬레이션으로 하나의 개체만 허용하는 단일체 패턴을 적용할게요.

단일체로 표현하기 위해 정적 멤버로 단일체를 참조하는 멤버 필드를 추가합니다. 그리고 정적 생성자에서 단일체를 생성합니다. 정적 생성자는 해당 형식을 사용하기 전에 동작하는 것을 보장하며 한 번만 동작합니다. 단일체를 생성하기 적합한 곳이죠. 그리고 생성자를 정의하세요. 단, 접근 지정은 디폴트 가시성을 갖는 private으로 지정하세요.

아래 코드는 단일체를 표현한 코드 예입니다.

class Singleton
{
    static Singleton singleton;
    static Singleton()
    {
        singleton = new Singleton();
    }
    Singleton()
    {
    }
}

using System;

namespace 택배_요금_계산_시뮬레이션
{
    public class City
    {
        readonly double relative_position;
        public string Name
        {
            get;
            private set;
        }
        public City(string name, double relative_position)
        {
            Name = name;
            this.relative_position = relative_position;
        }
        public double CalculateDistance(City city)
        {
            double distance = relative_position - city.relative_position;
            return Math.Abs(distance);
        }
    }
}

namespace 택배_요금_계산_시뮬레이션
{
    public class Parcel
    {
        public const int base_fee = 100;
        double weight;
        public Parcel(double weight)
        {
            this.weight = weight;
        }
        public double CalculateFee(double distance)
        {
            return weight * base_fee * distance;
        }
    }
}

using System;
using System.Collections.Generic;

namespace 택배_요금_계산_시뮬레이션
{
    class Application
    {
        #region 단일체 패턴
        static Application application;
        static Application()
        {
            application = new Application();
        }
        Application()
        {
        }
        #endregion
        List cities = new List();
        internal static void Run()
        {
            application.Init();
            application.Simulation();
        }

        private void Simulation()
        {
            City dep_city = SelectCity("도착 도시");
            if(dep_city == null)
            {
                Console.WriteLine("잘못 선택하였습니다.");
                return;
            }
            City arr_city = SelectCity("출발 도시");
            if(arr_city == null)
            {
                Console.WriteLine("잘못 선택하였습니다.");
                return;
            }
            Parcel parcel = MakeParcel();
            PrintDeliveryFee(dep_city, arr_city, parcel);
        }

        private void PrintDeliveryFee(City dep_city, City arr_city, Parcel parcel)
        {
            double distance = dep_city.CalculateDistance(arr_city);
            Console.WriteLine("택배 요금:{0}원", parcel.CalculateFee(distance));
        }

        private Parcel MakeParcel()
        {
            Console.WriteLine("무게 (Kg):");
            double weight = 0;
            double.TryParse(Console.ReadLine(), out weight);
            return new Parcel(weight);
        }

        private City SelectCity(string msg)
        {
            Console.Write("{0} (", msg);
            for(int i = 0; i<cities.Count; i++)
            {
                Console.Write("{0}:{1} ", i, cities[i].Name);
            }
            Console.Write("):");

            int index = 0;
            if(int.TryParse(Console.ReadLine(), out index)==false)
            {
                return null;
            }
            if((index<0)||(index>=cities.Count))
            {
                return null;
            }
            return cities[index];
        }

        private void Init()
        {
            cities.Add(new City("부산", 0));
            cities.Add(new City("대구", 105.84));
            cities.Add(new City("대전", 259.24));
            cities.Add(new City("서울", 397.40));
        }
    }
}

//http://ehpub.co.kr
//실습으로 다지는 C#
//택배 요금 계산 시뮬레이션

namespace 택배_요금_계산_시뮬레이션
{
    class Program
    {
        static void Main(string[] args)
        {
            Application.Run();
        }
    }
}

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#] 실현 관계(Realization) 실습

언휴 — Wed, 8 Jan 2025 09:00:55 +0900

[실습으로 다지는 C#] 실현 관계(Realization) 실습

이번 강의는 실현(Realization) 관계 실습입니다.

실현 관계는 기능을 약속한 형식과 이를 구체적으로 구현한 형식 사이의 관계입니다. 결국 인터페이스와 인터페이스에 약속한 기능을 구현한 형식 사이의 관계입니다.

기능을 약속한 형식과 약속한 기능을 구체적으로 구현한 형식 사이의 관계

이러한 실현 관계로 표현하였을 때 가장 큰 장점은 같은 방법으로 사용할 수 있다는 것입니다.

다음은 이번 실습에서 표현할 클래스 다이어그램입니다.

실현 관계 클래스 다이어그램

클래스 다이어그램에서 IStudy 인터페이스와 Student는 실현 관계입니다.

클래스 다이어그램에서 IStudy 인터페이스와 Gorillar도 실현 관계입니다.

클래스 다이어그램을 보면서 코드로 표현해 보세요. 특별한 알고리즘은 없어서 설명은 생략할게요. 주의할 점은 Student는 Man에서 파생하고 IStudy에 약속한 기능을 구현하고 있다는 것이죠. 둘 다 파생 문법으로 표현하지만 기반 형식인 Man을 먼저 표시해야 합니다.

class Student:Man, IStudy

namespace 실현_관계
{
    interface IStudy
    {
        void Study();
    }
}

namespace 실현_관계
{
    class Man
    {
        string name;
        public Man(string name)
        {
            this.name = name;
        }
        public override string ToString()
        {
            return name;
        }        
    }
}

using System;

namespace 실현_관계
{
    class Student : Man, IStudy
    {
        readonly int sn;
        public Student(string name,int sn):base(name)
        {
            this.sn = sn;
        }
        public void Study()
        {
            Console.WriteLine("{0} 공부합니다.",this);
        }
        public override string ToString()
        {
            return string.Format("{0}번 이름:{1}", sn, base.ToString());
        }
    }
}

using System;

namespace 실현_관계
{
    class Gorilla : IStudy
    {
        public void Study()
        {
            Console.WriteLine("나도 공부한다. 쿵쾅 쿵쾅");
        }
    }
}

//http://ehpub.co.kr
//실습으로 다지는 C#
//실현 관계(Realization)

using System;

namespace 실현_관계
{
    class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student("홍길동",1);
            Gorilla gorilla = new Gorilla();
            Console.WriteLine("생성한 학생:{0}", student);

            Test(student);
            Test(gorilla);
        }
        static void Test(IStudy istudy)
        {
            istudy.Study();
        }
    }
}

언제나휴일 여행 및 산책

독립기념

[실습으로 다지는 C#] 의존(Dependency) 관계 실습 – Part1

언휴 — Tue, 7 Jan 2025 13:00:03 +0900

의존관계(Dependency) 실습

이번 강의는 의존(Dependency) 관계 실습(Part 1 – 설계까지)입니다.

*아직 대리자(delegate)를 학습하기 전이면 간략히 보신 후에 대리자를 학습 후에 보시기 바랍니다.*

의존 관계는 원본 개체의 상태가 바뀌면 의존 개체의 상태도 바뀌는 형식 사이의 관계입니다. 그리고 팩토리 형식과 상품 형식 사이의 관계도 의존 관계로 표현합니다. 즉, 특정 형식 개체 생성을 책임지는 형식이 팩토리이고 팩토리에서 만들어지는 형식 개체가 상품 개체입니다.

의존관계 클래스다이어그

이번 실습에서는 Item 형식과 이를 화면에 노출하는 ItemControl 형식간의 관계를 표현할 것입니다. Item 형식 개체의 속성이 바뀌면 ItemControl 개체에서도 화면 내용을 변경해야겠죠. 이 때 Item 형식 개체를 원본 개체라고 부릅니다. 물론, ItemControl 개체는 의존 개체입니다.

그런데 Item 개체 정보가 바뀌었다는 것을 ItemControl은 어떻게 알수 있을까요? 의존 관계를 제공하기 위해서는 두 개체 사이에 Binding 정보를 관리할 수 있는 시스템 혹은 개체가 필요합니다. 여기에서는 BindingSystem을 정의합시다.

BindingSystem은 내부에 Item 개체 값이 바뀔 때 처리를 위한 이벤트를 멤버로 갖습니다. ItemControl은 BindingSystem에게 Item 개체 정보가 바뀔 때 처리할 이벤트 핸들러를 등록합니다.

Item 개체는 자신의 값이 바뀌면 BindingSystem에게 이를 통보할 거예요. 그리고 BindingSystem에서는 이벤트 핸들러를 등록한 것이 있으면 이를 호출합니다. 결국 ItemControl에서 등록한 이벤트 핸들러가 동작하는 것이죠.

이와 같은 원리로 ItemContrl은 Item 개체의 값이 바뀐 사실을 인지하고 화면에 바뀐 값을 출력할 수 있습니다.

의존관계 클래스 다이어그램

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#] 연관 관계(Association) 실습 – 의사, 약사

언휴 — Tue, 7 Jan 2025 12:51:57 +0900

[C#] 연관 관계(Association) 실습 – 의사, 약사

이번 강의는 연관 관계(Association) 실습입니다.

연관 관계는 두 형식 개체가 협업하는 관계입니다. 현실 세계에서는 수평적인 관계가 이상적이라 생각할 수 있어요. 하지만 프로그램 세계는 명확한 목적을 수행하는 목적 집단입니다. 목적 집단에서는 명확한 수직 관계로 조직화합니다.

프로그램에 연관 관계가 있을 때 협업하는 메서드를 수행할 때 매우 위험할 수 있어요. 서로 상대의 협업 메서드를 호출하면 실제 메서드는 끝나지 않고 스택 메모리 Overflow가 발생할 수 있는 것입니다.

이번 실습에서는 이러한 위험성을 확인해 보기로 해요.

실습할 소재는 의사와 약사 사이의 협업입니다.

의사는 “약사와 함께 일하다.”, “치료하다.” 기능을 제공합시다.

약사는 “의사와 함께 일하다.”, “조재하다.” 기능을 제공합시다.

이를 클래스 다이어그램으로 표시하면 두 형식 사이에 실선으로 연관 관계를 표시합니다.

연관 관계(Association) 클래스 다이어그

using System;

namespace 연관_관계_실습
{
    class Druggist
    {
        public void WorkWith(Doctor doctor)
        {
            Console.WriteLine("약사 - WorkWith");
            doctor.WorkWith(this);
            Hasty();
        }
        public void Hasty()
        {
            Console.WriteLine("조재하다.");
        }
    }
}

using System;

namespace 연관_관계_실습
{
    class Doctor
    {
        public void WorkWith(Druggist druggist)
        {
            Console.WriteLine("의사 - WorkWith");
            druggist.WorkWith(this);
            Treatment();
        }
        public void Treatment()
        {
            Console.WriteLine("치료하다.");
        }
    }
}

//http://ehpub.co.kr
//실습으로 다지는 C#
//연관(Association) 관계 실습 - 의사, 약사

using System;

namespace 연관_관계_실습
{
    class Program
    {
        static void Main(string[] args)
        {
            Doctor doctor = new Doctor();
            Druggist druggist = new Druggist();
            Console.ReadKey();
            doctor.WorkWith(druggist);
        }
    }
}

언제나휴일 여행 및 산책

독립기념관

[실습으로 다지는 C#] 직접 연관 관계(Direct Association) 실습 – 계산기, 사각형

언휴 — Sun, 5 Jan 2025 15:30:26 +0900

[실습으로 다지는 C#] 직접 연관 관계(Direct Association) 실습 – 계산기, 사각형

이번 강의는 직접 연관 관계(Direct Association) 실습입니다.

직접 연관 관계는 명령을 내리는 형식과 명령을 수행하는 형식 사이의 관계로 가장 흔한 관계입니다.

이번 실습은 계산기와 사각형을 소재로 실습해 봅시다.

계산기에서는 사각형 개체를 입력받아 면적을 계산하는 기능을 제공합니다.

사각형은 너비와 높이를 멤버 필드로 갖고 이들 값을 가져오기 속성을 제공합니다.

이를 클래스 다이이어그램으로 표시하면 계산기에서 사각형으로 실선 화살표로 표현할 수 있어요.

직접 연관 관계(Direct Association) 클래스 다이어그

namespace 직접_연관_관계_실습
{
    class Rectangle
    {
        public int Height
        {
            get;
            private set;
        }
        public int Width
        {
            get;
            private set;
        }
        public Rectangle(int height, int width)
        {
            Height = height;
            Width = width;
        }
    }
}

namespace 직접_연관_관계_실습
{
    class Calculator
    {
        public int CalculateArea(Rectangle rectnagle)
        {
            int width = rectnagle.Width;
            int height = rectnagle.Height;
            return width * height;
        }
    }
}

//http://ehpub.co.kr
//실습으로 다지는 C#
//14. 직접 연관(Direct Association) 관계 실습 - 계산기, 사각형

using System;

namespace 직접_연관_관계_실습
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Rectangle rectangle = new Rectangle(4,5);
            int area = calculator.CalculateArea(rectangle);
            Console.WriteLine("면적:{0}", area);
        }
    }
}

언제나휴일 여행 및 산책

에버랜드 크리스마스 퍼레이드 요정이 나타났다

[실습으로 다지는 C#] 구성(Composition) 관계 실습 – 사람, 눈

언휴 — Sun, 5 Jan 2025 15:00:49 +0900

[실습으로 다지는 C#] 구성(Composition) 관계 실습 – 사람, 눈

이번 강의는 구성(Composition) 관계 실습입니다.

소재는 사람과 눈입니다. 구성 관계는 소유 개체를 생성할 때 내부 개체가 같이 만들어지는 특징을 갖고 있습니다.

구성(Composition) 관계 클래스다이어그램

클래스 다이어그램을 바탕으로 코드를 구현해 보세요. 주의할 점은 Man 생성자에서 Eye 개체를 생성해야 한다는 것입니다.

별다른 알고리즘을 갖고 있는 것이 아니어서 코드 설명은 생략할게요.

using System;

namespace 구성_관계_실습
{
    class Eye
    {
        double sight;
        bool opened;
        public bool Opened
        {
            get
            {
                return opened;
            }
        }
        public Eye(double sight)
        {
            this.sight = sight;
        }
        public void Open()
        {
            Console.WriteLine("앞이 보이네. 시력:{0}", sight);
            opened = true;
        }
        public void Close()
        {
            Console.WriteLine("앞이 컴컴");
            opened = false;
        }
        public void See()
        {
            if(opened)
            {
                Console.WriteLine("앞이 잘 보여");
            }
            else
            {
                Console.WriteLine("앞이 안 보여");
            }
        }
    }
}

using System;

namespace 구성_관계_실습
{
    class Man
    {
        Eye[] eyes = new Eye[2];
        string name;
        public string Name
        {
            get
            {
                return name;
            }
        }
        public Man(string name)
        {
            this.name = name;
            eyes[0] = new Eye(2.0);
            eyes[1] = new Eye(2.0);
        }
        public void Walk()
        {
            if(eyes[0].Opened==false)
            {
                eyes[0].Open();
            }
            if (eyes[1].Opened == false)
            {
                eyes[1].Open();
            }
            Console.WriteLine("Go~");
        }
        public void Sleep()
        {
            if (eyes[0].Opened)
            {
                eyes[0].Close();
            }
            if (eyes[1].Opened)
            {
                eyes[1].Close();
            }
            Console.WriteLine("쿨~쿨~");
        }
        public override string ToString()
        {
            return name;
        }

    }
}

//http://ehpub.co.kr
//실습으로 다지는 C#
//구성 관계 실습

namespace 구성_관계_실습
{
    class Program
    {
        static void Main(string[] args)
        {
            Man man = new Man("홍길동");
            man.Walk();
            man.Sleep();
            man.Walk();
        }
    }
}

언제나휴일 여행 및 산책

독립기념관 통일 염원의 동산

[실습으로 다지는 C#] 집합(Aggregation) 관계 실습 – 쇼핑 센터, 상품

언휴 — Sun, 5 Jan 2025 14:30:28 +0900

[실습으로 다지는 C#] 집합(Aggregation) 관계 실습 – 쇼핑 센터, 상품

이번 강의는 집합(Aggregation) 관계를 코드로 표현하는 실습입니다.

실습 소재는 쇼핑 센터와 상품입니다. 집합 관계는 이처럼 컬렉션과 원소 사이의 관계입니다.

상품은 상품 이름, 가격, 회사 이름, 일련 번호를 갖습니다. 일련 번호는 순차적으로 자동 부여하며 상품은 쇼핑 센터에 입고할 수 있게 표현해 봅시다.

먼저 클래스 다이어그램을 작성해 보세요.

집합(Aggregation) 관계 클래스 다이어그

이를 코드로 작성합시다.

namespace 집합_관계
{
    public class Product
    {
        public string Name
        {
            get;
            private set;
        }
        public int Price
        {
            get;
            private set;
        }
        public string Company
        {
            get;
            private set;
        }
        readonly int pn;
        public int PN
        {
            get
            {
                return pn;
            }
        }
        static int lastpn;
        public Product(string name,int price,string company)
        {
            Name = name;
            Price = price;
            Company = company;
            lastpn++;
            pn = lastpn;
        }
        public override string ToString()
        {
            return Name;
        }
    }
}

using System.Collections;
using System.Collections.Generic;

namespace 집합_관계
{
    class Mall : IEnumerable
    {
        Dictionary<int, Product> pdic = new Dictionary<int, Product>();

        public bool InProduct(Product product)
        {
            if(pdic.ContainsKey(product.PN))
            {
                return false;
            }
            pdic[product.PN] = product;
            return true;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return pdic.Values.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return pdic.GetEnumerator();
        }
    }
}

//http://ehpub.co.kr
//실습으로 다지는 C#
//집합 관계 실습
using System;

namespace 집합_관계
{
    class Program
    {
        static void Main(string[] args)
        {
            Mall mall = new Mall();
            mall.InProduct(new Product("Escort C#", 5000, "언제나 휴일"));
            mall.InProduct(new Product("실습으로 다지는 C#", 5000, "휴일"));
            foreach(Product product in mall)
            {
                Console.WriteLine(product);
            }
        }
    }
}

언제나휴일 여행 및 산책

역사문화둘레길 2코스 유관순길

[실습으로 다지는 C#] 일반화 관계(Generalization) 실습 – 포유류, 호랑이, 사자

언휴 — Sun, 5 Jan 2025 14:00:25 +0900

[실습으로 다지는 C#] 일반화 관계(Generalization) 실습 – 포유류, 호랑이, 사자

이번 강의에서는 일반화 관계(Generalization)를 코드로 표현하는 실습입니다.

일반화 관계는 “A는 B이다.”로 표현할 수 있는 형식 사이의 관계라고 했어요. 이번 실습에서는 “호랑이는 포유류이다.”, “사자는 포유류이다.”를 표현할 거예요.

포유류는 공통적으로 새끼에게 젖을 물리는 행위를 합니다. 그리고 울기도 합니다. 물론, 호랑이와 사자는 울음 소리가 다르죠.

이러한 내용을 실습해 볼 거예요.

먼저 클래스 다이어그램을 작성하면 다음처럼 작성할 수 있어요.

일반화 관계

여러분께서 실습할 내용과 클래스 다이어그램을 토대로 구현을 해 보세요. 그리고 비교해 보시기 바랍니다.

기반 형식 포유류(Mammal)에는 울다(Cry) 메서드를 약속합니다. 기능을 구현하지 않고 약속만 할 때 abstract 키워드를 명시하여 추상 메서드로 만듭니다. 또한 추상 멤버가 하나라도 있다면 해당 형식은 반드시 추상 클래스로 정의하여야 합니다.

using System;

namespace 일반화_관계_실습
{
    abstract class Mammal
    {
        public abstract void Cry();
        public void Nurse()
        {
            Console.WriteLine("새끼에게 젖을 물리다.");
        }
    }
}

호랑이와 사자는 포유류를 기반으로 파생 형식으로 정의합니다. 그리고 기반 형식에 추상 메서드로 정의한 Cry를 반드시 재정의해 주어야 합니다.

using System;

namespace 일반화_관계_실습
{
    class Tiger:Mammal
    {
        public override void Cry()
        {
            Console.WriteLine("어흥~ 난 호랑이야.");
        }
    }
}

using System;

namespace 일반화_관계_실습
{
    class Lion:Mammal
    {
        public override void Cry()
        {
            Console.WriteLine("어흥~ 난 사자야.");
        }
    }
}

마지막으로 테스트하는 코드에서는 호랑이와 사자 개체를 생성하여 Cry와 Nurse 메서드를 호출해 보기로 합시다.

일반화 관계에서는 기반 형식에 정의한 멤버를 파생 형식에서 상속받는 특징이 있기 때문에 Nurse 메서드를 호출할 수 있어요.

//http://ehpub.co.kr
//실습으로 다지는 C#
//일반화 관계 실습 - 포유류, 호랑이, 사자

namespace 일반화_관계_실습
{
    class Program
    {
        static void Main(string[] args)
        {
            Mammal[] mammals = new Mammal[2];
            mammals[0] = new Tiger();
            mammals[1] = new Lion();

            foreach(Mammal mammal in mammals)
            {
                mammal.Cry();
                mammal.Nurse();
            }
        }
    }
}

실행 결과는 다음과 같습니다.

어흥~ 난 호랑이야.
새끼에게 젖을 물리다.
어흥~ 난 사자야.
새끼에게 젖을 물리다.

언제나휴일 여행 및 산책

역사문화둘레길 1코스 대한독립만세길

[실습으로 다지는 C#] 클래스 간의 관계

언휴 — Sun, 5 Jan 2025 13:30:29 +0900

[실습으로 다지는 C#] 클래스 간의 관계

이번 강의에서는 클래스 간의 관계를 알아볼 거예요.

클래스 다이어그램으로 관계를 나타낼 때 7가지의 관계가 있어요.

일반화 관계(Generalization)
집합 관계(Aggregation)
구성 관계(Composition)
직접 연관 관계(Direct Associtaion)
연관 관계 (Association)
의존 관계 (Dependency)
실현 관계 (Realization)

일반화 관계(Generalization)는 기반 형식과 파생 형식 사이의 관계입니다. “피아니스트는 음악가이다.” 처럼 “이다.”로 표현할 수 있는 형식 사이의 관계입니다. 음악가 종류에는 피아니스트, 드러머, 기타리스트 등이 있죠. 이 때 음악가를 기반 형식이라고 말하고 피아니스트를 파생 형식이라고 말합니다. UML에서는 삼각형과 실선으로 표현합니다.

피아니스트는 음악가이다.

일반화 관계(Generalization)

집합 관계(Aggregation)은 컬렉션과 원소 사이의 관계입니다. “필통은 연필과 지우개 등을 가지고 있다.” 처럼 “가지고 있다.” 혹은 “가질 수 있다.”로 표현할 수 있는 형식 사이의 관계입니다.

필통은 연필과 지우개 등을 가지고 있다.

집합 관계(Aggregation)

구성 관계(Composition)은 포함 형식과 내부 형식 사이의 관계입니다. “사람은 눈과 귀 등을 가지고 있다.” 처럼 “가지고 있다.” 혹은 “가질 수 있다.”로 표현할 수 있는 형식 사이의 관계입니다.

사람은 눈과 귀 등을 가지고 있다.

구성 관계(Composition)

이처럼 집합 관계와 구성 관계는 “가지고 있다.”로 표현할 수 있는 형식 사이의 관계입니다. 차이점은 집합 관계에서는 소유 개체와 피소유 개체가 만들어지는 과정이 별도로 진행합니다. 하지만 구성 관계에서는 동시에 진행합니다. 필통과 연필은 별도로 만들어지겠죠. 하지만 눈과 귀는 사람이 태어날 때 가지고 태어납니다.

집합 관계는 대부분 컬렉션과 원소 사이의 관계라고 생각할 수 있어요.

집합 관계는 컬렉션과 원소 사이의 관계

직접 연관 관계(Direct Association)는 가장 흔한 관계입니다. 명령을 내리는 형식과 이를 수행하는 형식 사이의 관계입니다.

고용주는 노동자에게 일을 시킨다.

직접 연관 관계(Direct Association)

연관 관계(Association)는 서로 상대를 알고 명령할 수 있는 관계입니다. 프로그램에서 위험한 관계이며 다른 안전한 관계로 바꿀 것은 권합니다.

연관 관계(Association)

의존 관계(Dependency)는 원본 개체의 변화에 따라 의존 개체도 변화하는 형식 사이의 관계입니다.

회원 정보가 바뀌면 회원 컨트롤에 표시한 정보를 변경한다.

그리고 어떠한 형식 개체를 생성하는 책임을 갖고 있을 때도 의존 관계로 표시합니다.

의존 관계(Dependency)

실현관계(Realization)는 약속한 기능을 구현하는 관계입니다.

실현관계(Realization)

언제나휴일 여행 및 산책

에버랜드 크리스마스 퍼레이드

[실습으로 다지는 C#] 캡슐화 실습 – 학생 클래스 정의하기

언휴 — Sun, 5 Jan 2025 13:00:56 +0900

[실습으로 다지는 C#] 캡슐화 실습 – 학생 클래스 정의하기

이번 강의에서는 캡슐화 실습을 해 봅시다.

캡슐화는 여러 개의 멤버를 하나의 형식으로 묶는 과정을 말합니다. 이번 실습에서는 학생 클래스를 정의하는 실습을 해 보기로 할게요.

실습할 학생 클래스의 멤버는 다음과 같아요.

학생 클래스
    멤버 필드
        아이큐
        매력
        번호 - 읽기 전용, 순차 부여
        이름
        가장 최근에 부여한 번호 - 정적 멤버
    멤버 메서드
        생성자(이름)
        공부하다(횟수)
        춤추다(횟수)
        노래하다(횟수)
        ToString 재정의
    멤버 속성
        get은 public, set private

OOP 프로그래밍에서는 구현할 프로그램을 UML 다이어그램을 이용하여 요구 분석 및 아키텍쳐링, 설계를 한 후에 구체적으로 구현하고 테스트를 하곤 하죠. 특히 형식을 정의할 때 이를 클래스 다이어그램으로 표시하고 형식과 형식 사이의 관계를 도식하곤 합니다.

여기서 실습할 학생 클래스를 클래스 다이어그램으로 표현하면 다음처럼 표현할 수 있어요.

학생 클래스 다이어그램

사각형을 삼등분하였을 때 첫 번째 칸은 클래스 이름, 두 번째 칸은 멤버 필드, 세 번째 칸은 멤버 메서드입니다.

그리고 멤버 앞에 + 표시는 public 접근 지정을 의미하고 -는 private 접근 지정을 의미합니다. 참고로 protected 접근 지정은 #으로 표시합니다.

lastnum과 get_LastNum처럼 밑줄 친 멤버는 정적 멤버를 의미합니다.

특수한 의미를 나타내기 위해 <<스테레오 타입>> 을 사용할 수도 있습니다.

이제 시나리오에 맞게 코드를 작성해 보세요. 메서드 내에서 구체적으로 수행할 작업은 여러분들이 추가적으로 시나리오를 작성하여 구현해 보세요. 그리고 난 후에 비교해 보시기 바랍니다.

using System;

namespace 캡슐화_실습___학생_클래스_정의하기
{
    class Student//학생 클래스
    {
        #region 멤버 필드
        int iq;//    아이큐
        int cp;//    매력
        readonly int num;//    번호
        string name;//    이름
        static int lastnum;//    가장 최근에 부여한 번호
        #endregion
        #region        //멤버 메서드
        public Student(string name)//    생성자
        {
            this.name = name;
            lastnum++;
            num = lastnum;
        }
        //    공부하다
        public void Study(int tcnt)
        {
            Console.WriteLine("{0}번 {1}학생 {2}횟수 공부하다.", num, name, tcnt);
            iq += tcnt;
        }
        //    춤추다
        public void Dance(int tcnt)
        {
            Console.WriteLine("{0}번 {1}학생 {2}횟수 춤추다.", num, name, tcnt);
            cp += tcnt;
        }
        //    노래하다
        public void Sing(int tcnt)
        {
            Console.WriteLine("{0}번 {1}학생 {2}횟수 노래하다.", num, name, tcnt);
            iq += tcnt / 2;
            cp += tcnt / 2;
        }
        //    ToString 재정의
        public override string ToString()
        {
            return string.Format("번호:{0} 이름:{1}", num, name);
        }
        #endregion
        #region//멤버 속성
        //    get은 public, set private
        public int IQ
        {
            get
            {
                return iq;
            }
            private set
            {                
                iq = value;
            }
        }
        public int CP
        {
            get
            {
                return cp;
            }
            private set
            {
                cp = value;
            }
        }
        public int Num
        {
            get
            {
                return num;
            }
        }
        public string Name
        {
            get
            {
                return name;
            }
            private set
            {
                name = value;
            }
        }
        public static int LastNum
        {
            get
            {
                return lastnum;
            }
        }
        
        #endregion
    }
}

//http://ehpub.co.kr
//실습으로 다지는 C#
//9. 캡슐화 실습 - 학생 클래스 정의하기
using System;


namespace 캡슐화_실습___학생_클래스_정의하기
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student("홍길동");
            Student stu2 = new Student("강감찬");
            Console.WriteLine(stu1);
            Console.WriteLine(stu2);

            stu1.Study(3);
            Console.WriteLine("번호:{0} 이름:{1} 아이큐:{2} 매력:{3}", stu1.Num, stu1.Name, stu1.IQ, stu1.CP);
            stu1.Dance(4);
            Console.WriteLine("번호:{0} 이름:{1} 아이큐:{2} 매력:{3}", stu1.Num, stu1.Name, stu1.IQ, stu1.CP);
            stu1.Sing(6);
            Console.WriteLine("번호:{0} 이름:{1} 아이큐:{2} 매력:{3}", stu1.Num, stu1.Name, stu1.IQ, stu1.CP);

            Console.WriteLine("가장 최근에 부여한 학생 번호:{0}", Student.LastNum);
        }
    }
}

실행 결과는 다음과 같습니다.

번호:1 이름:홍길동
번호:2 이름:강감찬
1번 홍길동학생 3횟수 공부하다.
번호:1 이름:홍길동 아이큐:3 매력:0
1번 홍길동학생 4횟수 춤추다.
번호:1 이름:홍길동 아이큐:3 매력:4
1번 홍길동학생 6횟수 노래하다.
번호:1 이름:홍길동 아이큐:6 매력:7
가장 최근에 부여한 학생 번호:2

언제나휴일 여행 및 산책

코타키나발루 IMAGO 대나무 전통춤 공연

[실습으로 다지는 C#] 랜덤 값 맞추기

언휴 — Sun, 5 Jan 2025 12:30:37 +0900

[실습으로 다지는 C#] 랜덤 값 맞추기

이번 강의에서는 컴퓨터가 생각한 랜덤 값(0~99)을 사용자가 10번 시도 내에 맞추는 프로그램을 만들어 봅시다.

먼저 문제를 해결하기 위한 논리를 생각하고 의사 코드(pseudo code)로 표현해 보세요. 여러분께서 먼저 작성한 후에 비교해 보세요.

rnum := 랜덤 값
반복(tcnt:1->10)                            
    guess := 추측값 입력
    조건(guess is equals rnum)                                    
        반복문 탈출
    조건(guess>rnum)
        더 작다고 알려준다.
    아니면
        더 크다고 알려준다.

조건(시도 횟수가 10보다 작거나 같으면)
    시도 횟수와 성공하였음을 알려준다.
아니면            
    실패하였다고 알려준다.

이제 프로젝트를 생성하여 의사 코드를 주석으로 처리하고 코드를 작성해 봅시다.

프로그램 시작부에 어떠한 프로그램인지 보여주기로 합시다. 참고로 C#에서 랜덤 값을 생성할 때 사용하는 형식은 Random 클래스입니다. 시작할 때 Random 형식 개체를 생성하세요.

Random random = new Random();
Console.WriteLine("0~99 사이의 정수 중에 컴퓨터가 생각한 수를 맞춰보세요.");
Console.WriteLine("*** 10회 안에 맞춰야 성공입니다.");

0~99 사이의 값 중에 랜덤 값을 발생시킵니다. Random 형식 개체의 Next 메서드를 호출하면 랜덤 값을 발생시킵니다. 만약 입력 인자로 정수 n을 전달하면 n가지(0~n-1) 정수 중에 하나의 랜덤 값을 반환합니다.

int rnum = random.Next(100);//rnum:= 랜덤 값

사용자는 총 10회 시도할 수 있습니다. 시도 횟수를 기억할 변수(tcnt)와 사용자가 예측한 정수를 기억할 변수(guess)를 선언하고 반복문을 작성합시다.

int tcnt;
int guess;
for(tcnt=1; tcnt<=10; tcnt++)//반복(tcnt: 1->10)
{
}

사용자에게 몇 번째 시도인지 알려주고 예상 값을 입력받습니다.

Console.Write("{0}번째 시도, 예상값:", tcnt);
int.TryParse(Console.ReadLine(), out guess);//guess:= 추측값 입력

예측한 값과 랜덤 값이 일치하면 반복문을 탈출합니다.

if(guess == rnum)//조건(guess is equals rnum)
{
    break;//반복문 탈출
}

일치하면 반복문을 탈출하였기 때문에 현재 반복문 내부라면 일치하지 않다는 것입니다. 이제 예측한 값이 랜덤 값보다 큰 지 판별하여 결과를 알려줍니다.

if(guess>rnum)//조건(guess > rnum)
{
    Console.WriteLine("더 작습니다.");//더 작다고 알려준다.
}
else//아니면
{
    Console.WriteLine("더 큽니다.");//더 크다고 알려준다.
}

이제 반복문에서 할 일은 끝났습니다. 반복문 수행 후에 성공하여 반복문을 나온 것이지 시도 횟수를 모두 사용하여 나온 것인지 판별합니다.

if(tcnt<=10)//조건(시도 횟수가 10보다 작거나 같으면)
{
    Console.WriteLine("{0}번 시도하여 정답을 맞추셨군요", tcnt);//시도 횟수와 성공하였음을 알려준다.
}
else//아니면
{
    Console.WriteLine("실패하였습니다.");//실패하였다고 알려준다.
}

마지막으로 컴퓨터가 생각한 랜덤한 정수를 알려줍니다.

Console.WriteLine("컴퓨터가 생각한 정수는 {0}", rnum);

프로젝트를 빌드한 후에 테스트를 수행하세요. 여기에서는 실행 결과는 생략할게요.

다음은 이번 실습에서 작성한 소스 코드입니다.

//ehpub.co.kr
//실습으로 다지는 C#
//8. 랜던 값 맞추기
using System;

namespace _008_랜덤_값_맞추기
{
    class Program
    {
        static void Main(string[] args)
        {
            Random random = new Random();
            Console.WriteLine("0~99 사이의 정수 중에 컴퓨터가 생각한 수를 맞춰보세요.");
            Console.WriteLine("*** 10회 안에 맞춰야 성공입니다.");

            int rnum = random.Next(100);//rnum:= 랜덤 값
            int tcnt;
            int guess;
            for(tcnt=1; tcnt<=10; tcnt++)//반복(tcnt: 1->10)
            {
                Console.Write("{0}번째 시도, 예상값:", tcnt);
                int.TryParse(Console.ReadLine(), out guess);//guess:= 추측값 입력
                if(guess == rnum)//조건(guess is equals rnum)
                {
                    break;//반복문 탈출
                }
                if(guess>rnum)//조건(guess > rnum)
                {
                    Console.WriteLine("더 작습니다.");//더 작다고 알려준다.
                }
                else//아니면
                {
                    Console.WriteLine("더 큽니다.");//더 크다고 알려준다.
                }
            }

            if(tcnt<=10)//조건(시도 횟수가 10보다 작거나 같으면)
            {
                Console.WriteLine("{0}번 시도하여 정답을 맞추셨군요", tcnt);//시도 횟수와 성공하였음을 알려준다.
            }
            else//아니면
            {
                Console.WriteLine("실패하였습니다.");//실패하였다고 알려준다.
            }
            Console.WriteLine("컴퓨터가 생각한 정수는 {0}", rnum);
        }
    }
}

언제나휴일 여행 및 산책

에버랜드 공연 Very Merry Santa Village

[실습으로 다지는 C#] 암스트롱의 수

언휴 — Sun, 5 Jan 2025 12:00:48 +0900

[실습으로 다지는 C#] 암스트롱의 수

이번 실습에서는 암스트롱의 수를 판별하는 메서드를 만들어 봅시다.

암스트롱의 수는 ABC = AXAXA + BXBXB + CXCXC인 정수를 말합니다. 예를 들어 153 = 1 = 125 + 27 입니다. 이러한 수를 암스트롱의 수라고 말합니다.

암스트롱의

이러한 암스트롱의 수를 판별하는 메서드를 만들기 전에 먼저 메서드 이름과 입력 매개 변수와 리턴 형식을 결정합니다. 언제나 알고리즘은 입력 인자와 수행 결과가 어떠한 것이 올 수 있는지를 판단할 수 있어야 합니다.

메서드 이름은 IsAmstrong으로 정할게요. 그리고 입력 인자는 판별할 정수가 필요하므로 정수형 변수 num으로 결정하고 반환은 판별 결과이므로 bool로 결정합시다.

bool IsAmstrong(int num)

이제 암스트롱의 수를 판별하는 알고리즘을 생각해 보세요. 그리고 이를 의사 코드(pseudo code)로 작성하고 주석으로 변환해 보세요.

bool IsAmstrong(int num)
{
    //조건(num이 3자리 정수가 아니라면)
        //거짓 반환
    //a := num의 100의 자리의 수
    //b := num의 10의 자리의 수
    //c := num의 1의 자리의 수
    //num2 = a의 3승 + b의 3승 + c의 3승
    //num이 num2와 같은지 판별 결과 반환
}

 이제 주석을 코드로 치환해 봅시다. 현재는 개발자가 추가 정의하는 형식이 없기 때문에 Program 클래스에 정적 메서드로 정의하세요.

static bool IsAmstrong(int num)
{
    if ((num < 100) || (num > 999))//조건(num이 3자리 정수가 아니라면)
    {
        return false;//거짓 반환
    }
    int a = num / 100;//a:= num의 100의 자리의 수
    int b = (num % 100) / 10; //b := num의 10의 자리의 수
    int c = num % 10;// c:= num의 1의 자리의 수
    int num2 = a * a * a + b * b * b + c * c * c;//num2 = a의 3승 + b의 3승 + c의 3승
    return num == num2;//num과 num2가 같은지 판별 결과 반환
}

이제 암스트롱의 수를 구하는 로직을 작성해 봅시다. 암스트롱의 수는 세 자리 정수이므로 100에서 999 사이의 정수를 확인해 보면 모든 암스트롱의 수를 알아낼 수 있겠죠.

static void Main(string[] args)
{
    Console.WriteLine("abc=a*a*a+b*b*b+c*c*c");
    for(int i = 100; i<1000;i++)
    {
        if(IsAmstrong(i))
        {
            Console.WriteLine("{0}", i);
        }
    }
}

실행하여 결과를 확인해 보세요.

abc=a*a*a+b*b*b+c*c*c
153
370
371
407

//ehpub.co.kr
//실습으로 다지는 C#
//7. 암스트롱의 수
//ABC = A의 3승 + B의 3승 + C의 3승
using System;


namespace _007_암스트롱의_수
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("abc=a*a*a+b*b*b+c*c*c");
            for(int i = 100; i<1000;i++)
            {
                if(IsAmstrong(i))
                {
                    Console.WriteLine("{0}", i);
                }
            }
        }
        static bool IsAmstrong(int num)
        {
            if ((num < 100) || (num > 999))//조건(num이 3자리 정수가 아니라면)
            {
                return false;//거짓 반환
            }
            int a = num / 100;//a:= num의 100의 자리의 수
            int b = (num % 100) / 10; //b := num의 10의 자리의 수
            int c = num % 10;// c:= num의 1의 자리의 수
            int num2 = a * a * a + b * b * b + c * c * c;//num2 = a의 3승 + b의 3승 + c의 3승
            return num == num2;//num과 num2가 같은지 판별 결과 반환
        }
            
    }
}

언제나휴일 산책 및 여행

아름드리공원 눈길 산책

[실습으로 다지는 C#] 두 개의 정수 사이의 합계 구하기

언휴 — Sun, 5 Jan 2025 11:30:45 +0900

[실습으로 다지는 C#] 두 개의 정수 사이의 합계 구하기

이번 강의에서는 두 개의 정수를 입력 받은 후에 두 개의 정수 사이의 합계를 구하는 실습을 해 봅시다.

먼저 어떻게 해야 문제를 해결할 수 있을지 생각한 후에 의사 코드(pseudo code) 형태로 작성해 보세요. 작성한 후에 비교해 보시기 바랍니다.

input := 정수를 입력 받는다.
 조건(정수로 변환(input,out num1)이 실패)
     오류를 출력 후 알고리즘 종료
 input := 정수를 입력 받는다.
 조건(정수로 변환(input,out num2)이 실패)
     오류를 출력 후 알고리즘 종료
 조건(num1<num2)
     두 수를 교환(ref num1, ref num2)
 sum:=두 정수 사이의 합계 구하기(num2,num1)

두 수를 교환(ref num1, ref num2)
     temp:= num1
     num1:= num2
     num2:= temp

두 정수 사이의 합계 구하기(start, end):합계
     sum:=0
     반복(value:= start->end)
         sum:= sum+value
     sum 반환

그리고 프로젝트를 생성한 후에 의사 코드를 주석으로 치환해 보세요. 두 수를 교환하는 부분과 두 정수 사이의 합계를 구하는 부분은 별도의 메서드로 정의해야겠죠.

마찬가지로 여러분께서 주석을 작성한 후에 비교해 보세요.

//http://ehpub.co.kr
//실습으로 다지는 C#
//5. 반복문 실습1
//두 개의 정수를 입력받은 후에 두 수 사이의 모든 정수의 합계 구하기
using System;

namespace _005_반복문_실습1___두_개의_정수를_입력받은_후에_두_수_사이의_모든_정수의_합계_구하기
{
    class Program
    {
        static void Main(string[] args)
        {
            //input:= 정수를 입력 받는다.
            //조건(정수로 변환(input, out num1)이 실패)
            {
                //    오류를 출력 후 알고리즘 종료                
            }

            //input := 정수를 입력 받는다.
            //조건(정수로 변환(input, out num2)이 실패)
            {
                //    오류를 출력 후 알고리즘 종료                
            }

            //조건(num1 < num2)
            {
                //    두 수를 교환(ref num1, ref num2)
            }

            //sum:= 두 정수 사이의 합계 구하기(num2, num1)            
        }

        //두 수를 교환(ref num1, ref num2)
        static void Swap(ref int num1, ref int num2)
        {
            //temp:= num1
            //num1:= num2
            //num2:= temp
        }

        //두 정수 사이의 합계 구하기(start, end):합계
        static int CalSum(int start, int end)
        {
            //sum:= 0
            //반복(value:= start->end)
            {
                //    sum:= sum + value
            }
            //sum 반환
            return 0;
        }
    }
}

이제 주석을 코드로 편집해 봅시다.

사용자로부터 입력받는 것은 문자열이므로 정수로 변환하는 작업이 필요합니다. 그리고 변환에 실패하였다면 사용자가 잘못 사용한 것으로 판단해야겠죠.

Console.WriteLine("첫 번째 정수를 입력하세요.");
string input = Console.ReadLine();//input:= 정수를 입력 받는다.
int num1;
if(int.TryParse(input,out num1)==false)//조건(정수로 변환(input, out num1)이 실패)
{
    Console.WriteLine("정수가 아닙니다.");//    오류를 출력 후 알고리즘 종료
    return;
}

Console.WriteLine("두 번째 정수를 입력하세요.");
input = Console.ReadLine();//input := 정수를 입력 받는다.
int num2;
if(int.TryParse(input,out num2) == false)//조건(정수로 변환(input, out num2)이 실패)

{
    Console.WriteLine("정수가 아닙니다.");//    오류를 출력 후 알고리즘 종료
    return;
}

두 개의 정수 중에 큰 값은 num1에 작은 값은 num2로 설정할게요. 이를 위해 num2가 더 크면 두 수를 교환합니다.

if(num1<num2)//조건(num1 < num2)
{
    Swap(ref num1, ref num2);//    두 수를 교환(ref num1, ref num2)
}

int sum = CalSum(num2, num1);   //sum:= 두 정수 사이의 합계 구하기(num2, num1)
Console.WriteLine("{0}에서 {1}사이의 합계는 {2}입니다.", num2, num1, sum);

//두 수를 교환(ref num1, ref num2) static void Swap(ref int num1, ref int num2) {    int temp = num1;//temp:= num1   num1 = num2;//num1:= num2    num2 = temp;//num2:= temp }

두 정수 사이의 합계를 구할 때는 합계를 0으로 초기화를 한 후에 반복해서 작은 값에서 큰 값 사이의 값들을 더하면 되겠죠. 이를 위해 반복문에서는 더해야 할 값을 작은 값으로 초기화하고 순차적으로 증가하면서 큰 값이 될 때까지 반복하게 해야 합니다. 그리고 반복해야 할 작업은 현재 합계와 변화하는 값을 더하는 작업을 해야겠죠.

//두 정수 사이의 합계 구하기(start, end):합계
static int CalSum(int start, int end)
{
    int sum = 0;//sum:= 0
    for (int value = start; value <= end; value++)//반복(value:= start->end)
    {
        sum += value;//    sum:= sum + value
    }
    return sum;//sum 반환            
}

이제 빌드 후에 테스트를 수행하세요.

=테스트 case1=
 첫 번째 정수를 입력하세요.
 1
 두 번째 정수를 입력하세요.
 100
 1에서 100사이의 합계는 5050입니다.
 =테스트 case2=
 첫 번째 정수를 입력하세요.
 100
 두 번째 정수를 입력하세요.
 1
 1에서 100사이의 합계는 5050입니다.
 =테스트 case3=
 첫 번째 정수를 입력하세요.
 1
 두 번째 정수를 입력하세요.
 백
 정수가 아닙니다.
 =테스트 case4=
 첫 번째 정수를 입력하세요.
 백
 정수가 아닙니다.

다음은 이번 실습에서 작성한 전체 소스 코드입니다.

//http://ehpub.co.kr
//실습으로 다지는 C#
//5. 반복문 실습1
//두 개의 정수를 입력받은 후에 두 수 사이의 모든 정수의 합계 구하기
using System;

namespace _005_반복문_실습1___두_개의_정수를_입력받은_후에_두_수_사이의_모든_정수의_합계_구하기
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("첫 번째 정수를 입력하세요.");
            string input = Console.ReadLine();//input:= 정수를 입력 받는다.
            int num1;
            if(int.TryParse(input,out num1)==false)//조건(정수로 변환(input, out num1)이 실패)
            {
                Console.WriteLine("정수가 아닙니다.");//    오류를 출력 후 알고리즘 종료
                return;
            }

            Console.WriteLine("두 번째 정수를 입력하세요.");
            input = Console.ReadLine();//input := 정수를 입력 받는다.
            int num2;
            if(int.TryParse(input,out num2) == false)//조건(정수로 변환(input, out num2)이 실패)
            {
                Console.WriteLine("정수가 아닙니다.");//    오류를 출력 후 알고리즘 종료
                return;
            }

            if(num1<num2) 조건(num1="" <="" num2)="" {="" swap(ref="" num1,="" ref="" num2);="" 두="" 수를="" 교환(ref="" }="" int="" sum="CalSum(num2," num1);="" sum:="두" 정수="" 사이의="" 합계="" 구하기(num2,="" num1)="" console.writeline("{0}에서="" {1}사이의="" 합계는="" {2}입니다.",="" num2,="" sum);="" static="" void="" temp="num1;//temp:=" num1="" num2="" 구하기(start,="" end):합계="" calsum(int="" start,="" end)="" 0="" for="" (int="" value="start;" value++)="" 반복(value:="start-">end)
            {
                sum += value;//    sum:= sum + value
            }
            return sum;//sum 반환            
        }
    }
}</num2)>

언제나휴일 여행 및 산책

겨울 에버랜드 Wintertopia with Moomin

프로그래밍 언어 및 기술 [언제나휴일]

2. 3 요구 사항 및 유즈케이스 매핑

언제나휴일 여행 및 산책

2. 2 유즈케이스 다이어그램

2.2.1 액터 개요

2.2.2 유즈케이스 다이어그램

언제나휴일 여행 및 산책

2. 요구 분석 및 정의 2.1 요구 리스트

2.1 요구리스트

언제나휴일 여행 및 산책

1. 7 .NET 리모팅

1.7.1 공통 라이브러리 제작

1.7.2 서버 예광탄 제작

1.7.3 클라이언트 제작

언제나휴일 여행 및 산책

1. 6 Windows Form

1.6.1 간단한 Windows Forms 응용 만들기

1.6.2 사용자 정의 컨트롤 만들기

언제나휴일 여행 및 산책

1. 5 라이브러리

1.5.1 .NET 어셈블리 구성 요소

1.5.2 .NET 어셈블리 만들기

1.5.3 전용 어셈블리

1.5.4 공용 어셈블리

1.5.5 XML 문서 파일

언제나휴일 여행 및 산책

1. 4 요구 기술

1. 3 시나리오

I. 개요

I.1 배경지식

I.2 프로젝트 소개

II. 동작 환경 및 요구 기술

II.1 동작환경

II.2 요구 기술

III. 개발 공정

언제나휴일 여행 및 산책

1. 2 개요

언제나휴일 여행 및 산책

1. 1 검색 엔진

언제나휴일 여행 및 산책

1. 검색 엔진 소개 및 개요

언제나휴일 여행 및 산책

0. 들어가기에 앞서

언제나휴일 여행 및 산책

[C언어 소스] 연결리스트를 이용하여 구현한 큐

알고리즘

소스 코드

언제나휴일 여행 및 산책

[C언어 소스] 부분 문자열 복사하는 함수 만들기(버퍼 오버플로우 방지)

알고리즘

소스 코드

언제나휴일 여행 및 산책

[C언어 소스] 부분 문자열 복사하는 함수 만들기

알고리즘

부분 문자열 복사 실행 화면 소스코드

언제나휴일 여행 및 산책

[C언어 소스] 문자열 복사하는 함수 만들기(버퍼 오버플로우 방지)

알고리즘

소스 코드

언제나휴일 여행 및 산책

[C언어 소스] 문자열 복사하는 함수 만들기

알고리즘

언제나휴일 여행 및 산책

[C언어 소스] 부분 문자열 비교하는 함수 만들기

알고리즘

소스코드

언제나휴일 여행 및 산책

[C언어 소스] 문자열 비교하는 함수 만들기

알고리즘

소스코드

언제나휴일 여행 및 산책

[C언어 소스] 문자열 길이를 계산하는 함수 만들기

언제나휴일 여행 및 산책

[C언어] n 개의 정수 중에 홀수의 합계 구하는 함수 만들기

언제나휴일 여행 및 산책

[C언어 소스] 속이 빈 삼각형 출력

언제나휴일 여행 및 산책

[C언어 소스] 산봉우리 출력

언제나휴일 여행 및 산책

[C언어 소스] 숫자 피라미드

부분 문자열 복사 실행 화면

소스코드