U E D R , A S I H C RSS

AcceleratedC++/Chapter8

1. Chapter 8 Writing generic functions

WikiPedia:Generic_function : ํ•จˆ˜ ํ˜ธถœํ•˜ธฐ  „Œ€Š” ทธ ํ•จˆ˜˜ งคฐœ€ˆ˜ ํƒ€ž…ด ฌด—‡ธ€ •Œ ˆ˜ —†Š” ํ•จˆ˜.
Ch9~Ch12 WikiPedia:Abstract_data_type (ดํ•˜ ADT)˜ ตฌํ˜„„ ณต€ํ•œ‹ค.
ฐธณ ํŽ˜ด€) ParametricPolymorphism

1.1. 8.1 What is a generic function?

WikiPedia:Generic_function : ํ•จˆ˜˜ ํ˜ธถœ‹œ ธž ํƒ€ž…ด‚˜ ฆฌํ„ดํƒ€ž…„ ‚ฌšฉž€ •Œ ˆ˜—†‹ค. ex)find(B,E,D)
ํ•จˆ˜˜ ํ˜ธถœ‹œ ํ•จˆ˜˜ งคฐœ€ˆ˜ operandกœ ํ•˜—ฌ ํ–‰ํ•ด€Š” operator˜ œ ํšจ„„ ปดํŒŒŸฌ€ กฐ‚ฌ. ‚ฌšฉ €Šฅ„„ ํŒ‹จ
~cpp  ex) union(A, B) { return A+B; }
  union(A:string, " is...") (O), concaternate("COL", " is...") (X)
ทธ ‡‹คฉด –ด–ปฒŒ ํ•จˆ˜€ –ด– ํ•œ žฃŒตฌกฐ งŒ ‹œํ‚คŠ”€ ํŒ‹จํ•  ˆ˜ žˆŠ”€?
ฐ˜ณตž ƒฐํ•ดณดž. งŒ•ฝ ํŠ • žฃŒตฌกฐ€ ฐ˜ณตž ฆฌํ„ดํ•˜Š” ฉค„ํ•จˆ˜ ฐ–Š” ‹คฉด ฐ˜ณตž ธžกœ ฐ›Š” function“ค— Œ€ํ•ด„œ ทธ žฃŒตฌกฐŠ” œ ํšจํ•˜‹คณ  ํŒ‹จํ•  ˆ˜ žˆ‹ค.

1.1.1. 8.1.1 •Œ ค€€ •Š€ ํƒ€ž…˜ ค‘•™ ฐ’

template
„œกœ ‹คฅธ ํƒ€ž…˜ ฐฒดด„ ํ•˜”„ ฐฐ˜ ฐฒด €€ณ  ํ–‰ํ•˜Š” ํ–‰™–‘‹€ ณตํ†ต˜ ํ–‰™–‘‹„ ฐ–Š”‹ค.
Runtimeด •„‹ˆ Compile ํƒ€ž„— ‹ค œกœ ํƒ€ž…ด €ํ™”ํ•˜Š” ฐฒด   ˆํžˆ ž‘„ํ•˜ฉด ˜ฌฐ”ฅธ ™ž‘„ ณดžฅํ•œ‹ค.

~cpp 
//median.h
#ifndef GUARD_median_h
#define GUARD_median_h

#include <algorithm>
#include <stdexcept>
#include <vector>

using std::domain_error;
using std::sort;
using std::vector;
template <class T> 	// type งคฐœ€ˆ˜˜ € •, ด ํ•จˆ˜˜ scope•ˆ—„œŠ” ฐดํ„ฐ ํ˜•„ Œ€‹ ํ•œ‹ค.
T median(vector<T> v)
{
	typedef typename vector<T>::size_type vec_sz; 	// typename— Œ€ํ•ด„œ •Œž

	vec_sz size = v.size();
	if (size == 0)
		throw domain_error("median of an empty vector");

	sort(v.begin(), v.end());

	vec_sz mid = size/2;

	return size % 2 == 0 ? (v[mid] + v[mid-1]) / 2 : v[mid];	// double, int—Š” œ ํšจ, string€ operator / € —†ธฐ •Œฌธ— ฌดํšจ
}
#endif
 
‹ค œ ปดํŒŒ‹œ ปดํŒŒŸฌŠ” ํ”„กœทธž˜จธ€ € •ํ•œ ํƒ€ž…œกœ ด ํ•จˆ˜ ธŠคํ„Šคํ™” ‹œœ„œ ƒ„ํ•˜ณ  ฐ”ธ”ฉํ•œ‹ค.
typename € •„ง ธŠคํ„Šคํ™” ˜€ •Š€ ํ•จˆ˜ ปดํŒŒŸฌ€ ฝ–ด“ค•Œ ํƒ€ž… งคฐœ€ˆ˜™€ €„œ ํƒ€ž…˜ ํ˜•„ ƒ„ํ• •Œ •ž— ถ™—ฌ• ํ•˜Š” ํ‚ค›Œ“œ ž„. ex) vector<T> or vector<T>::size_type

1.1.2. 8.1.2 ํ…œํ”Œฆฟ ธŠคํ„Šคํ™”

STL€ ‹ค œกœ ํ•จˆ˜˜ ธŠคํ„Šคํ™”— €ํ•œ ํ‘œ€ ธ ฐฉ‹„  œ •ํ•˜€ •Š•˜‹ค. ”ฐ„œ ฐ ปดํŒŒŸฌงˆ‹ค „œกœ ‹คฅธ ฐฉ‹œกœ ํ•จˆ˜ ธŠคํ„Šคํ™”ํ•œ‹ค. ”ฐ„œ ž‹ ˜ ปดํŒŒŸฌ˜ ํŠง•„ ํŒŒ•…ํ•˜Š” …ธ ฅด ํ•„š”.
  • ปดํŒŒ งํฌ ชจธ Compiler : ‹ค œกœ ธŠคํ„Šค€ งŒ“ค–ด€ธฐ  „Œ€Š” ํ…œํ”Œฆฟ ฝ”“œ˜ œ ํšจ„„ •Œ ˆ˜ —†‹ค. —ŸฌŠ” งํฌ‹œ— ฐœƒ
  • …ž  ฐฉ‹˜ template ชจธ Compiler : ตœ˜ ฐฉ‹. ธŠคํ„Šคํ™” œ„ํ•ด„œ STL  •˜€— Œ€ํ•œ  ‘ด ํ•„š”.

1.1.3. 8.1.3  œ„ฆญ ํ•จˆ˜™€ ํƒ€ž…

‹ค œ  œ„ฆญ ํ•จˆ˜˜ ‚ฌšฉ—„œ €žฅ ฌธ œ‹œ ˜Š” ฒƒ€ ํ•จˆ˜‚ด€˜ —ฐ‚ฐ„ งคฐœ€ˆ˜ ํƒ€ž…ด €›„ ํ•˜Š” €ด‹ค.
find(B, E, D) D˜ ธžฃŒ [B, E) „ตํ•˜—ฌ ฐ’„ ฐพŠ”‹ค. „ต ํ•˜Š” ฒƒ€ ํฌฒŒ ฌธ œ˜€ •ŠŠ”‹ค.
accumulate(B, E, D) D˜ ธž˜ ํ˜•„ ธฐ€œกœ [B, E) „ตํ•˜—ฌ ฐ’„ ชจ€‹ค. ฆฌํ„ฐ’ด D˜ žฃŒํ˜•— ˜ํ–ฅ„ ฐ›ธฐ •Œฌธ— ฌธ œ˜ ฐœƒ†Œ€€ กดžฌํ•œ‹ค.
~cpp ex) accumulate(v.begin(), v.end(), 0.0); // งŒ•ฝ 0:int ‚ฌšฉํ–ˆ‹คฉด ˜ฌฐ”ฅธ ™ž‘„ ณดžฅํ•  ˆ˜ —†‹ค.
max ํ•จˆ˜˜ ตฌํ˜„
~cpp 
template <class T>
T max(const T& left, const T& right)
{	
	return left > right ? left : right;
}
 
ธžกœ ฐ›€ ‘ ฐ’˜ ํƒ€ž…ด ™„ „ํžˆ ฐ™•„•€งŒ ˜ฌฐ”ฅธ ™ž‘„ ณดžฅฐ›Š”‹ค. ธžŠ” operator>(T, T) €›ํ•ด•ํ•œ‹ค.

1.2. 8.2 Data-structure independence

find(c.begin(), c.end(), val) ฐ˜ ธ ํ•จˆ˜˜ ž‘„ €Šฅ. ฐ˜ณตž ํ†ตํ•ด„œ ฐ˜ณตž€  œณตํ•˜Š” ฐฉ‹œกœ ™ž‘€Šฅ
c.find(val) ํŠ •ํ˜•˜ ธŠคํ„Šคธ c ํ†ตํ•ด„œงŒ  ‘€Šฅ. ‚ดžฅฐฐ—ด—  šฉ ถˆ€Šฅ
find(c, val) ฒ”œ„ € •ด ถˆ€Šฅํ•˜ณ , œ šฉ„ด ฒซฒˆงธ˜ ฒฝšฐณด‹ค  ‹ค.
  • 1˜ ฐฉ‹œกœ ž‘„œ ํ•จˆ˜œด rbegin() ฐ™€ ํ…œํ”Œฆฟ ฉค„ ํ•จˆ˜ ดšฉํ•ด„œ —ญˆœ €ƒ‰„ €Šฅํ•˜ฒŒ ž‘„œ‹ค.

1.2.1. 8.2.1 •Œณ ฆฌฆ˜ ฐ˜ณตž

STL ํ•จˆ˜ ณดฉด ธžกœ ฐ›Š” ฐ˜ณตž(iterator)— ”ฐ„œ ปจํ…Œด„ˆ˜ ํ•จˆ˜ ‚ฌšฉ œ ํšจ„„ •Œ ˆ˜ žˆ‹ค.
˜ˆ “คžฉด find(B, E, D)ฐ™€ ํ•จˆ˜˜ ฒฝšฐ •„ ‹จˆœํ•œ  œํ•œ  —ฐ‚ฐงŒ„ ดšฉํ•˜ธฐ •Œฌธ— Œ€€„˜ ปจํ…Œด„ˆ— Œ€ํ•ด„œ ‚ฌšฉด €Šฅํ•˜‹ค. ทธŸฌ‚˜ sort(B, E)ฐ™€ ฒฝšฐ—Š” ธฐณธ ธ ‚ฌ™—ฐ‚ฐ“ค„ ฐ˜ณตž— Œ€ํ•ด„œ ‚ฌšฉํ•˜ธฐ •Œฌธ— ดŸฐ —ฐ‚ฐ„ €›ํ•˜Š” string, vector งŒด ™„ฒฝํ•˜ฒŒ €›œ‹ค.
STL€ ดŸฐ „ฅ˜ œ„ํ•ด„œ 5ฐœ˜ ฐ˜ณตž ดํ…Œณ ฆฌ(iterator category)  •˜ํ•˜—ฌ ฐ˜ณตž „ฅ˜ํ•œ‹ค. ดํ…Œณ ฆฌ˜ „ฅ˜Š” ฐ˜ณตž˜ š”†Œ  ‘ํ•˜Š” ฐฉฒ•—”ฐฅธ „ฅ˜ดฉฐ, ดŠ” •Œณ ฆฌฆ˜˜ ‚ฌšฉ œ ํšจ„ —ฌ€ ฒฐ •ํ•˜Š”ฐ „›€ด œ‹ค.

1.2.2. 8.2.2 ˆœฐจ  ฝธฐ- „šฉ  ‘

€ชจ“  ˆœฐจฐ˜ณตž—„œŠ” -- —ฐ‚ฐ„ ํ•  ˆ˜ —†‹ค.
find ตฌํ˜„ 1
~cpp template <class In, class X> In find(In begin, In end, const X& x) {
	while(begin != end && *begin != x)
		++begin:
	return begin;
}
 
find ตฌํ˜„ 2
~cpp 
template <class In, class X> In find(In begin, In end, const X& x) {
	if (begin == end || *begin == x)
		return begin;
	begin++;
	return find(begin, end, x);
}
 
ƒธฐ 2ฐœ˜ ตฌํ˜„ ชจ‘ begin, end iterator ˆœฐจ œกœ  ‘ํ•˜ณ  žˆŒ„ •Œ ˆ˜ žˆ‹ค. ƒธฐ˜ ํ•จˆ˜ ํ†ตํ•ด„œ ˆœฐจ ฝธฐ- „šฉ˜ ฐ˜ณตžŠ” ++( „,ํ›„œ„), ==, !=, * €›ํ•ด•ํ•œ‹คŠ” ฒƒ„ •Œ ˆ˜ žˆ‹ค. ง ถ™—ฌ„œ ->, .™€ ฐ™€ ฉค„ ฐธกฐ —ฐ‚ฐž„ ํ•„š”กœํ•˜‹ค. (7.2 ˆ— ‚ฌšฉํ–ˆ–ค —ฐ‚ฐžด‹ค.)
ƒธฐ™€ ฐ™€ ฐ˜ณตž ž… ฅ ฐ˜ณตž(input iterator)ณ  ํ•จ.

1.2.3. 8.2.3 ˆœฐจ  “ฐธฐ- „šฉ  ‘

copy ตฌํ˜„
~cpp 
template <class In, class Out> Out copy(In begin, In end, Out dest) {
	if (begin != end)
		*dest++ = *begin++;
	return dest;
}
 
class In ํ˜•˜ ฐ˜ณตžŠ” ํ•จˆ˜€ „ํ–‰˜Š” ™•ˆ ฐ˜ณตž ํ†ตํ•ด„œ ฝธฐ —ฐ‚ฐงŒ„ ˆ˜ํ–‰ํ•œ‹ค. class Out ํ˜•˜ ฐ˜ณตžŠ” *dest++ = *begin++; ˜ —ฐ‚ฐ„ ํ†ตํ•ด„œ “ฐธฐ —ฐ‚ฐ„ ˆ˜ํ–‰ํ•œ‹ค. ”ฐ„œ class Out ฐ˜ณตžŠ” ++( „,ํ›„œ„). = —ฐ‚ฐžงŒ„ ํ‰€ํ• ˆ˜ žˆœฉด œ‹ค.
class Out ฐ˜ณตž ถœ ฅ— ฐฐํƒ€ œกœ ‚ฌšฉํ•˜ คฉด ++ —ฐ‚ฐด Œ€ž…ฌธ ‚ฌด—„œ 1ฒˆดƒ€ ฌดํšจ€ ˜„ก งŒ“ค–ด –ด•ํ•œ‹ค.
ƒธฐ š”ตฌ‚ฌํ•ญ„ งŒ‹œํ‚คŠ” ฒฝšฐ˜ ฐ˜ณตž ถœ ฅ ฐ˜ณตž(Output iterator)ณ  ํ•จ.
ชจ“  ปจํ…Œด„ˆŠ” back_inserter(class T) ํ†ตํ•ด„œ ถœ ฅ ฐ˜ณตž ฆฌํ„‹œํ‚ฌ ˆ˜ žˆ‹ค. ด ฐ˜ณตžŠ” write-once˜ ํŠ„„ €„‹ค.

1.2.4. 8.2.4 ˆœฐจ  ฝธฐ-“ฐธฐ  ‘

replace ตฌํ˜„
~cpp 
template <class For, class X> void replace(For begin, For end, const X& x, const X& y) {
	while (beg != end) {
		if (*beg == x)
			*beg = y;
		++beg;
	}
}
 
[begin, end) ˜ ฒ”œ„•ˆ—„œ x ฐพ•„„œ yกœ ˜ํ™˜ํ•œ‹ค.
—ฌธฐ„œ begŠ” ž… ฅ ฐ˜ณตž, ถœ ฅ ฐ˜ณตž 2€€˜ ํŠ„„ ชจ‘ งŒ‹œœ• ํ•œ‹ค.
*, ++( „,ํ›„œ„), ==, =, ., ->™€ ฐ™€ —ฐ‚ฐด €Šฅํ•˜‹คฉด ˆœฐฉํ–ฅ ฐ˜ณตž(forward iterator)ณ  ํ•จ.

1.2.5. 8.2.5 —ญฐฉํ–ฅ  ‘

reverse ตฌํ˜„
~cpp 
template <class Bi> void reverse(Bi begin, Bi end) {
	while (begin != end) {
		--end;

		if (begin != end)
			swap(*begin++, *end);
	}
}
 
begin end ˜ š”†Œ „ตํ•˜—ฌ ‹คฅด‹คฉด swap()‹œํ‚จ‹ค.
ˆœฐฉํ–ฅ —ฐ‚ฐž˜ ชจ“  —ฐ‚ฐ„ €›ํ•˜ณ  --—ฐ‚ฐ„ €›ํ•œ‹คฉด ด ฐ˜ณตžŠ” –‘ฐฉํ–ฅ ฐ˜ณตž(bidirection iterator) ณ  €ฅธ‹ค. ํ‘œ€ ดธŒŸฌฆฌ ปจํ…Œด„ˆ ํดž˜Šค“ค€ ชจ‘ –‘ฐฉํ–ฅ ฐ˜ณตž €›ํ•จ.

1.2.6. 8.2.6 ž„˜  ‘

binary search ตฌํ˜„
~cpp 
template <class Ran, class X> bool binary_search(Ran begin, Ran end, const X& x) {
	while (begin < end) {
		Ran mid = begin + (end - begin ) /2;
		if (x < *mid)
			end = mid;
		else if (*mid < x)
			begin = mid + 1;
		else return true;
	}
	return false;
}
 
ฐธณ žฃŒ) WikiPedia:Binary_searchฐ”ด„ˆฆฌ „œ˜
ž„˜  ‘ ฐ˜ณตž˜ ฒฝšฐ –‘ฐฉํ–ฅ ฐ˜ณตž˜ ชจ“  ํŠ„ ํ•จป˜ ‹คŒ ฐ™€ —ฐ‚ฐ„ งŒํ•œ‹ค.
condition p:iterator, q:iterator, n:integer
p+n, p-n, n+p, p+q, pn, p<q, p>q, p<=q, p>q

ž„˜  ‘ ฐ˜ณตžฅด ดšฉํ•˜Š” •Œณ ฆฌฆ˜€ sort. vector, string งŒด ž„˜  ‘ ฐ˜ณตž €›ํ•œ‹ค. listŠ”  ฅธ ฐดํ„˜ ‚ฝž…, ‚ญ œ— ตœ ํ™” ˜—ˆธฐ •Œฌธ— ˆœฐจ ธ  ‘งŒ €Šฅํ•จ.

1.2.7. 8.2.7 ฐ˜ณตž ฒ”œ„ ฐ  €‚œ ฐ’

ฐ˜ณตž˜ ฐ’œกœ ปจํ…Œด„ˆ˜ งˆ€ง‰ š”†Œ—„œ ํ•œฐœ€ €‚œ ฐ’„ ‚ฌšฉํ•˜Š” ดœ 
  • งˆ€ง‰ š”†Œ ฒ”œ„˜ œกœ ‚ฌšฉํ•จœกœจ ฐœƒํ•˜Š” ํŠ„ํ•œ ฒ˜ฆฌ —†• Š” ฒƒด €Šฅ. (‹คˆ˜€ „–ด“ฌ)
  • งˆ€ง‰ š”†Œ ฒ”œ„˜ œกœ  •ํ•  ฒฝšฐ ฒ”œ„•ˆ— ฐพŠ” ฒƒด —†„•Œ ด •Œ คŠ” ˆ˜‹จด €žฌํ•˜‹ค.
  • ‹จˆœํžˆ != —ฐ‚ฐœกœ ฒ”œ„˜ ˆœํšŒ งˆ˜Š” กฐœกœ ดšฉด €Šฅํ•˜‹ค. <>™€ ฐ™€ ํฌธฐ —ฐ‚ฐž€ ถˆํ•„š”ํ•˜‹ค.
  • ‘ฒˆงธ ธžกœ ํ•˜‚˜€ €‚œ ฐ’„ ฐ–„กํ•จœกœจ ž—ฐŠคŸฝฒŒ out-of-range˜ ƒํ™ฉ„ ํŒŒ•…ํ•˜Š” ฒƒด €Šฅํ•˜‹ค.
    ~cpp 
     c.end() == c.begin() + c.size()    // this is true
     
  • 1.3. 8.3 Input and output iterators

    ž…ถœ ฅ ฐ˜ณตžŠ” ปจํ…Œด„ˆ˜ ฐ˜ณตžด™ธ˜ กดžฌํ•˜Š” ฐ˜ณตž ํ‘œํ˜„ํ•˜ธฐ •Œฌธ— ˆœฐฉํ–ฅ ฐ˜ณตž™€ ตฌ„‹œํ‚ด.
    istream, ostream ˜ ฐ˜ณตž –ปŒœกœจ ž…ถœ ฅ ŠคํŠธ„  œ–ดํ•˜Š” ฒƒด €Šฅํ•˜‹ค.
    ~cpp 
    vector<int> v;
    copy(istream_iterator<int>(cin), istream_iterator<int>(), back_inserter(v));
    //istream_iterator<int> Š” end-of-file, —Ÿฌƒํƒœ €ฆฌํ‚จ‹ค.
    
    C++˜ ชจ“  ž…ถœ ฅ —ฐ‚ฐ€ ํƒ€ž… € •—ฐ‚ฐด‹ค. cin>>s.midterm>>s.final>>s.homework; —„œ„ ํƒ€ž…— ”ฐ„œ ‹คฅธ „ ํ•œ‹ค.

    1.4. 8.4 Using iterators for flexibility

    ~cpp 
    #include <algorithm>
    #include <cctype>
    #include <string>
    
    using std::find_if;
    using std::string;
    
    using std::isspace;
    
    inline bool space(char c)
    {
            return isspace(c);
    }
    
    inline bool not_space(char c)
    {
            return !isspace(c);
    }
    
    template <class Out>                             // changed
    void split(const string& str, Out os) {          // changed
    
    	typedef string::const_iterator iter;
    
    	iter i = str.begin();
    	while (i != str.end()) {
    		// ignore leading blanks
    		i = find_if(i, str.end(), not_space);
    
    		// find end of next word
    		iter j = find_if(i, str.end(), space);
    
    		// copy the characters in `[i,' `j)'
    		if (i != str.end())
    			*os++ = string(i, j);   // changed
    
    		i = j;
    	}
    }
    
    Class Out € ˆœฐฉํ–ฅ, ž„˜ ‘, ถœ ฅ ฐ˜ณตž˜ š”ตฌ‚ฌํ•ญ„ ชจ‘ ฐ˜ํ•˜ธฐ •Œฌธ— istream_iteratorงŒ •„‹ˆฉด –ด–ค ฐ˜ณตž—„ “ฐ ˆ˜ žˆ‹ค. ฆ‰, ํŠ •€ˆ˜กœ˜  €žฅ ฟงŒ•„‹ˆ console, file กœ˜ ostream œกœ˜ ถœ ฅ„ €›ํ•œ‹ค. ํ  Œ€‹จํ•˜ตฐ..
    ----
    AcceleratedC++
    Valid XHTML 1.0! Valid CSS! powered by MoniWiki
    last modified 2021-02-07 05:22:25
    Processing time 0.0433 sec