IT 프로그래밍/자료구조

[자료구조] 프로그래밍과제1 그룹액티비티

기술1 2024. 10. 20. 10:34
반응형
#include <iostream>
using namespace std;

int main ()
{
	int firstvalue, secondvalue;
	int* mypointer;

	mypointer = &firstvalue;
	*mypointer = 10;
	mypointer = &secondvalue;
	*mypointer = 20;

	cout << "firstvalue is " << firstvalue << '\n';
	cout << "secondvalue is " << secondvalue << '\n';
}

10, 20 결과값 출력

 

#include <iostream>
using namespace std;

int main ()
{
	int firstvalue = 5, secondvalue = 15;
	int* p1, * p2;

	p1 = &firstvalue;
	p2 = &secondvalue;
	*p1 = 10;
	*p2 = *p1;
	p1 = p2;
	*p1 = 20;

	cout << "firstvalue is" << firstvalue << '\n';
	cout << "secondvalue is" << secondvalue << '\n';
}

10, 20 결과값 출력

 

먼ㅁ저 5와 15ㅊ로 초기화된 변수입니다. 이후 p1은 firstvalue의 주소를 가리키도록 설정합니다. p1이 가리키는 변수를 10으로 벼녁ㅇ합니다. 이후 p2가 가리키는 변수의 값을 p1이 가리키는 변수의 값으로 설정합니다. 이때 p1이 이제 secondvalue의 주소를 가리키도록 변경합니다. p1, p2 모두 secondvalue의 주소를 가리키게 됩니다. 이후 p1에 20을 넣으면 p2만 20으로 바뀌는 것입니다.

#include <iostream>
using namespace std;

int main ()
{
	int numbers[5];
	int* p;
	p = numbers;
	*p = 10;
	p++;

	*p = 20;
	p = &numbers[2];
	*p = 30;
	p = numbers + 3;
	*p = 40;
	p = numbers;
	*(p + 4) = 50;

	for (int n = 0; n < 5; n++)
		cout << numbers[n] << ", ";
	return 0;
}

10, 20, 30, 40, 50 출력

 

#include <iostream>
using namespace std;


void increment_all(int *start, int* stop)
{
	int* current = start;
	while(current != stop)
	{
		++(*current);
		++current;
	}
}

void print_all(const int* start, const int* stop)
{
	const int* current = start;
	while(current != stop)
	{
		cout << *current << '\n';
		++current;
	}
}


int main ()
{
	int numbers[] = { 10, 20, 30 };
	increment_all(numbers, numbers + 3);
	print_all(numbers, numbers + 3);
	return 0;
}

설명:
이 함수는 배열의 첫 번째 요소부터 끝까지 하나씩 순차적으로 접근하여, 각 요소의 값을 1씩 증가시킵니다.
current = start;: 포인터 current가 배열의 첫 번째 요소를 가리키도록 설정합니다.
while (current != stop): current가 stop을 가리키기 전까지 반복합니다. 이 때, stop은 배열의 마지막 요소 다음 주소를 의미합니다.
++(*current);: 현재 가리키는 배열 요소의 값을 1 증가시킵니다.
++current;: 포인터를 다음 배열 요소로 이동시킵니다.

\

#include <iostream>
using namespace std;


void increase(void* data, int psize)
{
	if(psize == sizeof(char))
	{
		char* pchar;
		pchar = (char*)data;
		++(*pchar);
	}
	else if(psize == sizeof(int))
	{
		int* pint;
		pint = (int*)data;
		++(*pint);
	}
}

int main()
{
	char a = 'x';
	int b = 1602;
	increase(&a, sizeof(a));
	increase(&b, sizeof(b));
	cout << a << ", " << b << '\n';
	return 0;
}

배열 하나씩 늘려주는 것

 

#include <iostream>
using namespace std;


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

int subtraction(int a, int b)
{
	return a - b;
}

int operation(int x, int y, int(*functocall)(int, int))
{
	int g;
	g = (*functocall)(x, y);
	return (g);
}

int main()
{
	int m, n;
	int (*minus)(int, int) = subtraction;

	m = operation(7, 5, addition);
	n = operation(20, m, minus);
	cout << n;
	return 0;
}

+ - 는 기본적인 함수이며

 

functocall을 받아서 그 함수 포인터로 가리키는 함수를 호출하는 것이 있습니다. (*functocall)(x, y) 함수 포인터를 이용하여, 전달된 함수를 호출하고 그 결과를 g에 저장합니다. 전달된 함수의 결과를 반환합니다.

 

int (*minus)(int, int) = subtraction;은 subtracion 함수를 가리키는 함수 포인터 minus를 선언하고, subtraction 함수로 초기화하는 것입니다. operation 또한 여기에 포인터로 전달됩니다.

 

#include <string> // 문자열(string) 라이브러리 포함
#include <iostream> // 입출력(iostream) 라이브러리 포함

int main() {
    std::string str("Test string"); // 문자열 "Test string"을 str이라는 변수에 저장
    for (unsigned i = 0; i < str.length(); ++i) // 문자열 길이만큼 반복문 실행
        std::cout << str.at(i); // 문자열의 각 문자를 하나씩 출력
    return 0; // 프로그램 정상 종료
}

 

  • for (unsigned i = 0; i < str.length(); ++i):
    • for 반복문을 사용하여 문자열의 길이만큼 반복합니다.
    • **i**는 문자열의 인덱스를 나타내며, str.length()는 문자열의 길이를 반환합니다. (이 경우 "Test string"의 길이는 11입니다.)
    • **unsigned**는 음수가 없는 양의 정수 타입을 의미합니다. 문자열의 인덱스가 항상 0 이상의 값이므로 unsigned를 사용합니다.
  • str.at(i):
    • **str.at(i)**는 i번째 문자를 반환합니다.
    • std::cout << str.at(i): std::cout을 사용하여 i번째 문자를 화면에 출력합니다.
      • 예를 들어, i가 0일 때는 'T', i가 1일 때는 'e'를 출력하는 방식입니다.
  • return 0;:
    • 프로그램이 정상적으로 종료되었음을 나타냅니다.
#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

int main() {
    std::string name("John");    // "John" 문자열을 name 변수에 저장
    std::string family("Smith"); // "Smith" 문자열을 family 변수에 저장

    name += " K. ";  // name 문자열에 " K. "을 추가 (name = "John K. ")
    name += family;  // name 문자열에 family 문자열을 추가 (name = "John K. Smith")
    name += '\n';    // name 문자열에 줄바꿈 문자를 추가

    std::cout << name; // 최종 문자열 name을 출력 ("John K. Smith\n")

    return 0; // 프로그램 정상 종료
}

 

 

 

#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

int main() {
    std::string str;                  // 빈 문자열 str 선언
    std::string str2 = "Writing ";    // str2에 "Writing " 문자열 저장
    std::string str3 = "print 10 and then 5 more"; // str3에 "print 10 and then 5 more" 문자열 저장

    str.append(str2);                 // str에 str2를 추가 (str = "Writing ")
    str.append(str3, 6, 3);           // str에 str3의 일부를 추가 (str = "Writing 10")
    str.append("dots are cool", 5);   // str에 문자열의 일부를 추가 (str = "Writing 10 dots")
    
    std::cout << str << '\n';         // str을 출력
    return 0;
}

 

  • std::string str2 = "Writing ";:
    • **str2**에 "Writing " 문자열을 저장합니다.
  • std::string str3 = "print 10 and then 5 more";:
    • **str3**에 "print 10 and then 5 more" 문자열을 저장합니다.
  • str.append(str2);:
    • append 함수는 str 문자열에 str2 문자열을 이어 붙입니다.
    • 즉, **str**은 "Writing "이 됩니다.
  • str.append(str3, 6, 3);:
    • **str3**의 일부를 **str**에 추가합니다. 여기서 6은 **str3**에서 6번째 위치부터(0부터 시작) 3개의 문자를 잘라서 **str**에 붙이는 것을 의미합니다.
    • **str3**에서 6번째 위치는 **"10 "**입니다. 여기서 "10"이라는 3개의 문자가 잘려서 **str**에 추가됩니다.
    • 즉, **str**은 "Writing 10"이 됩니다.
  • str.append("dots are cool", 5);:
    • 여기서 문자열 **"dots are cool"**에서 처음 5개의 문자를 잘라서 **str**에 붙입니다.
    • 첫 5개의 문자는 **"dots "**입니다. 이것이 **str**에 추가됩니다.
    • 결과적으로 **str**은 "Writing 10 dots"가 됩니다.
  • std::cout << str << '\n';:
    • **str**에 저장된 결과 문자열을 콘솔에 출력합니다.
    • 출력 결과는 **"Writing 10 dots"**입니다.
  • return 0;:
    • 프로그램이 정상적으로 종료되었음을 나타냅니다.

 

 

#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

int main() {
    std::string str("This is an example sentence.");  // 문자열 str에 "This is an example sentence."를 저장
    std::cout << str << '\n';  // 문자열을 출력
    
    str.erase(10, 8);  // 문자열의 10번째 위치부터 8개의 문자를 삭제
    std::cout << str << '\n';  // 결과 출력
    
    str.erase(str.begin() + 9);  // 문자열의 9번째 위치의 문자를 삭제
    std::cout << str << '\n';  // 결과 출력
    
    str.erase(str.begin() + 5, str.end() - 9);  // 5번째 위치부터 끝에서 9번째 위치까지의 문자들을 삭제
    std::cout << str << '\n';  // 결과 출력
    
    return 0;
}

 

  • str.erase(10, 8);:
    • erase 함수는 10번째 위치(0부터 시작)에서 8개의 문자를 삭제합니다.
    • 10번째 문자는 "e"입니다("example"의 시작)이고, 그 이후로 "example "라는 단어가 8개의 문자입니다.
    • 따라서, **"example "**가 삭제됩니다.
    • 변경 후 문자열: This is an sentence.
    • 출력 결과: This is an sentence.
  • str.erase(str.begin() + 9);:
    • 이 코드는 문자열의 9번째 위치(0부터 시작)의 문자를 삭제합니다.
    • 9번째 위치는 "n"입니다("an"에서 "n").
    • 변경 후 문자열: This is a sentence.
    • 출력 결과: This is a sentence.
  • str.erase(str.begin() + 5, str.end() - 9);:
    • 5번째 위치부터 끝에서 9번째 위치까지의 문자를 삭제합니다.
    • 5번째 위치는 "i"이며, 끝에서 9번째 위치는 "a"입니다.
    • 따라서 **"is a"**가 삭제됩니다.
    • 변경 후 문자열: This sentence.
    • 출력 결과: This sentence.
#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

using namespace std;

int main() {
    string str = "this is a test string.";  // str에 "this is a test string." 문자열 저장
    string str2 = "n example";              // str2에 "n example" 문자열 저장
    string str3 = "sample phrase";          // str3에 "sample phrase" 문자열 저장

    str.replace(9, 5, str2);                // str의 9번째 위치부터 5개의 문자를 str2로 교체
    cout << str << '\n';                    // 결과 출력
    
    str.replace(str.begin(), str.end() - 3, str3);  // str 전체(끝에서 3자리를 제외한)를 str3으로 교체
    cout << str << '\n';                    // 결과 출력
    
    return 0;
}

 

 

  • string str = "this is a test string.";:
    • **str**에 "this is a test string."이라는 문자열을 저장합니다.
  • string str2 = "n example";:
    • **str2**에 "n example"이라는 문자열을 저장합니다.
  • string str3 = "sample phrase";:
    • **str3**에 "sample phrase"라는 문자열을 저장합니다.
  • str.replace(9, 5, str2);:
    • replace 함수는 문자열의 일부를 다른 문자열로 대체합니다.
    • 여기서는 **str**의 9번째 위치부터 5개의 문자(즉, "test ")를 **str2**로 교체합니다.
    • "this is a test string."에서 9번째 위치는 **"t"**이고, 그 뒤 5개의 문자는 **"test "**입니다. 따라서, **"test "**가 **"n example"**로 교체됩니다.
    • 변경 후 문자열: "this is an example string."
    • 출력 결과: this is an example string.
  • str.replace(str.begin(), str.end() - 3, str3);:
    • 이 코드에서는 str 문자열의 시작 위치부터 끝에서 3개 문자를 제외한 부분을 **str3**으로 교체합니다.
    • 즉, **"this is an example str"**를 **"sample phrase"**로 교체하고, 끝의 **"ing."**는 그대로 남습니다.
    • 변경 후 문자열: "sample phraseing."
    • 출력 결과: sample phraseing.
#include <iostream>  // 표준 입출력 라이브러리 포함
#include <cstring>   // C 문자열 처리 함수 (strtok 등) 포함
#include <string>    // C++ 문자열(string) 라이브러리 포함

using namespace std;

int main() {
    string str("Please split this sentence into tokens");  // C++ string으로 문자열 선언
    char *cstr = new char[str.length() + 1];  // 문자열을 C 스타일로 변환하기 위해 동적 메모리 할당 (null 문자 포함)
    
    strcpy(cstr, str.c_str());  // C++ string을 C 스타일 문자열로 복사
    
    char *p = std::strtok(cstr, " ");  // 공백(" ")을 기준으로 첫 번째 토큰 추출
    while (p != 0) {
        cout << p << '\n';  // 현재 토큰 출력
        p = std::strtok(NULL, " ");  // 다음 토큰 추출 (NULL로 계속 이전 상태 유지)
    }

    delete[] cstr;  // 동적 할당한 메모리 해제
    return 0;
}

 

 

  • string str("Please split this sentence into tokens");:
    • C++ string 객체인 **str**에 "Please split this sentence into tokens"라는 문자열을 저장합니다.
  • char *cstr = new char[str.length() + 1];:
    • C++ 문자열(std::string)을 C 스타일의 문자열(char*)로 변환하기 위해 동적 메모리를 할당합니다.
    • str.length() + 1: 문자열의 길이와 마지막에 들어갈 **널 종료 문자('\0')**를 포함하여 메모리 공간을 할당합니다.
  • strcpy(cstr, str.c_str());:
    • str.c_str(): C++ 문자열 객체를 C 스타일의 문자열로 변환하는 함수입니다. 이를 이용해 strcpy 함수로 문자열을 **cstr**에 복사합니다.
  • char *p = std::strtok(cstr, " ");:
    • std::strtok() 함수는 문자열을 특정 구분자(여기서는 공백 " ")를 기준으로 나눕니다.
    • **cstr**에서 첫 번째 토큰(단어)을 추출하여 **p**에 저장합니다. 첫 번째 호출 시에는 문자열과 구분자를 전달합니다.
  • while (p != 0):
    • **std::strtok()**은 다음 토큰이 있을 때마다 해당 토큰을 반환하며, 더 이상 토큰이 없을 경우 NULL을 반환합니다.
    • **p**가 NULL이 될 때까지 반복문을 수행합니다.
  • cout << p << '\n';:
    • 현재 토큰(단어)을 출력합니다.
  • p = std::strtok(NULL, " ");:
    • **std::strtok()**을 반복 호출하여, 이전 호출에서 나누어진 문자열의 다음 토큰을 찾습니다. 처음 호출 이후에는 NULL을 첫 번째 인자로 전달하여 이전 상태를 유지합니다.
    • 계속해서 다음 토큰을 추출하고, 더 이상 토큰이 없으면 NULL을 반환합니다.
  • delete[] cstr;:
    • 동적으로 할당한 메모리를 해제하여 메모리 누수를 방지합니다.
#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

using namespace std;

int main() {
    string str("There are two needles with needles.");  // str에 "There are two needles with needles." 문자열 저장
    string str2("needle");  // str2에 "needle" 문자열 저장

    size_t found = str.find(str2);  // str에서 str2("needle")를 처음 찾은 위치를 found에 저장
    if (found != string::npos)  // "needle"을 찾으면 해당 위치 출력
        cout << found << '\n';

    found = str.find("needles are small", found + 1, 6);  // "needles are small"에서 첫 6글자("needle")를 str에서 검색
    if (found != string::npos)  // 찾으면 해당 위치 출력
        cout << found << '\n';

    str.replace(str.find(str2), str2.length(), "preposition");  // "needle"을 찾아서 "preposition"으로 교체
    cout << str << '\n';  // 변경된 문자열 출력

    return 0;
}

 

상세 설명

  1. string str("There are two needles with needles.");:
    • **str**에 "There are two needles with needles."라는 문자열을 저장합니다.
  2. string str2("needle");:
    • **str2**에 "needle" 문자열을 저장합니다.
  3. size_t found = str.find(str2);:
    • find 함수는 **str**에서 str2("needle")을 찾아, 그 첫 번째 위치를 반환합니다.
    • **size_t**는 양의 정수를 저장하는 자료형이며, **found**는 **"needle"**의 위치를 저장합니다.
    • find 함수는 처음 찾은 위치의 인덱스를 반환하며, 만약 찾지 못하면 string::npos 값을 반환합니다.
  4. if (found != string::npos):
    • find 함수가 "needle"을 찾으면 **found**에 인덱스 값을 저장하고, 찾지 못하면 string::npos 값을 반환합니다.
    • 이 조건문은 **"needle"**을 찾았는지 확인합니다.
    • 출력 결과: "needle"은 14번째 위치에서 처음 발견됩니다. 따라서 14가 출력됩니다.
  5. found = str.find("needles are small", found + 1, 6);:
    • 이 줄에서는 "needles are small"이라는 문자열에서 앞 6개의 문자("needle")를 **str**에서 다시 검색합니다.
    • **found + 1**로 검색 범위를 첫 번째 "needle" 이후로 설정하여, 다음 "needle"을 찾습니다.
    • 출력 결과: 두 번째 "needle"은 29번째 위치에서 발견되므로 29가 출력됩니다.
  6. str.replace(str.find(str2), str2.length(), "preposition");:
    • replace 함수는 문자열의 일부를 다른 문자열로 대체하는 함수입니다.
    • str.find(str2): str2("needle")을 찾은 첫 번째 위치를 반환합니다.
    • str2.length(): "needle"의 길이(6)를 반환합니다.
    • replace 함수는 첫 번째 "needle"을 **"preposition"**으로 교체합니다.
    • 변경 후 문자열: "There are two preposition with needles."
  7. cout << str << '\n';:
    • 변경된 문자열을 출력합니다.
    • 출력 결과: "There are two preposition with needles."
 
#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

using namespace std;

int main() {
    string str("Please, replace the vowels in this sentence by asterisks.");
    // 문자열 str에 "Please, replace the vowels in this sentence by asterisks."를 저장
    
    size_t found = str.find_first_of("aeiou");
    // 문자열에서 처음으로 나타나는 'a', 'e', 'i', 'o', 'u' 중 하나를 찾고, 그 위치를 found에 저장

    while (found != string::npos) {  // 모음을 찾을 때까지 반복
        str[found] = '*';  // 찾은 위치의 문자를 '*'로 대체
        found = str.find_first_of("aeiou", found + 1);  // 다음 모음을 찾음
    }

    cout << str << '\n';  // 최종적으로 모음이 '*'로 대체된 문자열 출력
    return 0;
}

상세 설명

  1. string str("Please, replace the vowels in this sentence by asterisks.");:
    • **str**에 "Please, replace the vowels in this sentence by asterisks."라는 문자열을 저장합니다.
  2. size_t found = str.find_first_of("aeiou");:
    • find_first_of 함수는 주어진 문자 집합 중에서 첫 번째로 나타나는 문자의 위치를 반환합니다.
    • 여기서는 문자열 **str**에서 처음으로 나타나는 모음 중 하나("aeiou")를 찾고, 그 위치를 **found**에 저장합니다.
    • 만약 문자를 찾지 못하면, **string::npos**를 반환하여 더 이상 찾을 문자가 없음을 의미합니다.
    • 예를 들어, 문자열 "Please,..."에서 **첫 번째 모음은 'e'**이며, 위치는 2입니다.
  3. while (found != string::npos):
    • **found**가 **string::npos**가 아니라면(즉, 모음을 찾았다면), 반복문을 계속 실행합니다.
    • 모음을 찾지 못하면 반복문을 종료합니다.
  4. str[found] = '*';:
    • **str[found]**는 찾은 위치의 문자를 가리키며, 이를 '*'로 대체합니다.
    • 예를 들어, 첫 번째 모음 'e'가 위치한 **str[2]**는 이제 **'*'**로 변경됩니다.
  5. found = str.find_first_of("aeiou", found + 1);:
    • 다음 모음을 찾기 위해, 현재 찾은 위치 다음부터 다시 **find_first_of**를 호출합니다.
    • **found + 1**은 다음 문자부터 검색을 시작하겠다는 의미입니다.
    • 이렇게 반복하여 문자열 전체를 탐색합니다.
  6. cout << str << '\n';:
    • 모든 모음을 별표로 대체한 후, 최종 문자열을 출력합니다.

find_first_of() 함수의 동작 방식

**find_first_of("aeiou")**는 다음과 같은 방식으로 동작합니다:

  1. find_first_of 함수는 문자열의 각 문자를 하나씩 확인합니다.
  2. **"aeiou"**는 find_first_of 함수가 문자 집합으로 해석합니다. 즉, 이 함수는 문자열에서 'a', 'e', 'i', 'o', 'u' 중 하나라도 먼저 나타나는 문자를 찾습니다.
  3. 예를 들어:
    • **"Please,..."**에서 첫 번째 'e'를 찾습니다. 'e'는 **"aeiou"**에 포함된 문자이므로 그 위치(2)를 반환합니다.
#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

using namespace std;

int main() {
    string str = "We think in generalities, but we live in details.";  
    // str 문자열에 "We think in generalities, but we live in details."을 저장
    
    string str2 = str.substr(3, 5);  
    // str 문자열의 3번째 위치부터 5개의 문자를 추출하여 str2에 저장
    
    size_t pos = str.find("live");  
    // "live" 문자열을 str에서 찾아, 그 시작 위치를 pos에 저장
    
    string str3 = str.substr(pos);  
    // pos 위치부터 문자열의 끝까지를 추출하여 str3에 저장
    
    cout << str2 << ' ' << str3 << '\n';  
    // str2와 str3을 출력 (중간에 공백 포함)
    
    return 0;
}

상세 설명

  1. string str = "We think in generalities, but we live in details.";:
    • 문자열 **str**에 "We think in generalities, but we live in details."를 저장합니다.
  2. string str2 = str.substr(3, 5);:
    • substr() 함수는 문자열의 일부를 추출하는 함수입니다.
    • **substr(3, 5)**는 3번째 위치(0부터 시작)부터 5개의 문자를 추출하여 **str2**에 저장합니다.
    • **"We think in generalities, but we live in details."**에서 3번째 위치는 't'이며, 그 이후로 5개의 문자를 추출하면 **"think"**가 됩니다.
    • 결과적으로, **str2**는 "think"를 저장합니다.
  3. size_t pos = str.find("live");:
    • find() 함수는 문자열에서 특정 문자열을 찾는 함수입니다.
    • **str.find("live")**는 **"live"**라는 문자열이 처음으로 등장하는 위치를 찾아서 **pos**에 저장합니다.
    • **"We think in generalities, but we live in details."**에서 **"live"**는 35번째 위치에서 시작합니다.
    • 따라서 **pos = 35**가 됩니다.
  4. string str3 = str.substr(pos);:
    • **substr(pos)**는 pos 위치에서 문자열 끝까지를 추출합니다.
    • **pos = 35**이므로, 35번째 위치부터 끝까지 추출된 문자열은 **"live in details."**가 됩니다.
    • 따라서 **str3**에는 "live in details."가 저장됩니다.
  5. cout << str2 << ' ' << str3 << '\n';:
    • **str2**와 **str3**를 공백으로 구분하여 출력합니다.
    • **str2**는 "think"이고, **str3**는 "live in details."입니다.
    • 출력 결과는 **"think live in details."**가 됩니다.
#include <iostream>  // 표준 입출력 라이브러리 포함
#include <string>    // 문자열(string) 라이브러리 포함

using namespace std;

int main() {
    string str1("green apple");  // str1에 "green apple" 문자열 저장
    string str2("red apple");    // str2에 "red apple" 문자열 저장

    // str1과 str2가 같지 않으면
    if (str1.compare(str2) != 0)
        cout << str1 << " is not " << str2 << '\n';  // "green apple is not red apple" 출력

    // str1의 6번째 위치부터 5글자가 "apple"과 같으면
    if (str1.compare(6, 5, "apple") == 0)
        cout << "still, " << str1 << " is an apple\n";  // "still, green apple is an apple" 출력

    // str2의 마지막 5글자가 "apple"과 같으면
    if (str2.compare(str2.size() - 5, 5, "apple") == 0)
        cout << "and " << str2 << " is also an apple\n";  // "and red apple is also an apple" 출력

    // str1의 6번째부터 5글자와 str2의 4번째부터 5글자가 같으면
    if (str1.compare(6, 5, str2, 4, 5) == 0)
        cout << "therefore, both are apples\n";  // "therefore, both are apples" 출력

    return 0;
}

상세 설명

  1. string str1("green apple");:
    • 문자열 **str1**에 **"green apple"**을 저장합니다.
  2. string str2("red apple");:
    • 문자열 **str2**에 **"red apple"**을 저장합니다.
  3. str1.compare(str2):
    • compare() 함수는 두 문자열을 비교하여, 결과값을 반환합니다:
      • 0: 두 문자열이 같을 때
      • 양수: **str1**이 **str2**보다 사전순으로 클 때
      • 음수: **str1**이 **str2**보다 사전순으로 작을 때
    • **str1.compare(str2) != 0**는 **str1**과 **str2**가 같지 않으면 true가 됩니다.
    • 결과: "green apple"과 "red apple"은 다르므로 "green apple is not red apple"이 출력됩니다.
  4. str1.compare(6, 5, "apple"):
    • **compare(6, 5, "apple")**는 **str1**의 6번째 위치부터 5개의 문자가 **"apple"**과 같은지 비교합니다.
    • **str1**의 6번째 위치는 "a"이고, 6번째부터 5글자는 **"apple"**입니다.
    • 결과: 같으므로 "still, green apple is an apple"이 출력됩니다.
  5. str2.compare(str2.size() - 5, 5, "apple"):
    • **compare(str2.size() - 5, 5, "apple")**는 **str2**의 마지막 5개의 문자가 **"apple"**과 같은지 비교합니다.
    • **str2.size() - 5**는 **str2**에서 마지막 5글자의 시작 위치를 나타내며, **"apple"**을 가리킵니다.
    • 결과: 같으므로 "and red apple is also an apple"이 출력됩니다.
  6. str1.compare(6, 5, str2, 4, 5):
    • **compare(6, 5, str2, 4, 5)**는 **str1**의 6번째 위치부터 5글자와 **str2**의 4번째 위치부터 5글자를 비교합니다.
    • **str1**의 6번째부터 5글자는 **"apple"**이고, **str2**의 4번째부터 5글자도 **"apple"**입니다.
    • 결과: 같으므로 "therefore, both are apples"이 출력됩니다
반응형

'IT 프로그래밍 > 자료구조' 카테고리의 다른 글

[자료구조] 프로그래밍 과제1  (0) 2024.10.20
[자료구조] 그룹액티비티2  (1) 2024.10.20
스택과 C++ STL 컨테이너  (0) 2024.10.15
[자료구조] Generic 프로그래밍과 C++ Template  (0) 2024.10.15
[자료구조] class ArrayStack  (0) 2024.10.15

'IT 프로그래밍/자료구조'의 다른글

  • 현재글[자료구조] 프로그래밍과제1 그룹액티비티

관련글

티스토리툴바