U E D R , A S I H C RSS

AcceleratedC++/Chapter4

2. Chapter 4 Organizing programs and data

  • –ด๋–ค ข…๋ฅ˜˜ ๋ฌธ œ๋ฅผ ‘ผ๋‹ค.
  • ๋‹ค๋ฅธ ๊ฒƒ๋“ค๊ณผ ๋…๋ฆฝ ด๋‹ค.
  • ด๋ฆ„„ ๊ฐ€ง€๊ณ  žˆ–ด•ผ •œ๋‹ค.

    3žฅ๊นŒง€ ๋ดค๋˜ ๊ฒƒ€ ฒซ๋ฒˆงธ๊ฒƒ๋งŒ žˆ๊ณ , ๋‚˜๋จธง€ ๊ฒƒ€ —†๋‹ค. ”„๋กœ๊ทธ๋žจด ž‘„๋•Œ๋Š” ๋ณ„๋กœ ƒ๊ด€—†ง€๋งŒ, ปคง€๊ธฐ ‹œž‘•˜๋ฉด„œ๋ถ€„ฐ 2,3๋ฒˆงธ ๊ฒƒด ๊ฒฐ—ฌ๋˜๋ฉด, ๋‚˜ค‘—”  œ–ด๊ฐ€ ๋ถˆ๊ฐ€๋Šฅ•ด„๋‹ค. C++—„œ๋Š” ๋‹ค๋ฅธ –ธ–ด™€ ๋งˆฐฌ๊ฐ€ง€๋กœ •จˆ˜ + ž๋ฃŒ๊ตฌกฐ๋ฅผ  œ๊ณต•จœผ๋กœจ, ”„๋กœ๊ทธ๋žจ„ ๊ตฌกฐ™”‹œ‚ฌˆ˜ žˆ๋Š” ๋ฐฉ๋ฒ•„  œ๊ณต•œ๋‹ค. ๋˜•œ •จˆ˜ + ž๋ฃŒ๊ตฌกฐ๋ฅผ ๋ฌถ–ด„œ ๊ฐ€ง€๊ณ  ๋†€ ˆ˜ žˆ๋Š” class๋ผ๋Š” ๋„๊ตฌ๋ฅผ  œ๊ณต•ดค€๋‹ค.(Chapter9๋ถ€„ž„žˆ ‚ดŽด๋ณธ๋‹ค.)
    ๊ทธ๋Ÿฌ๋ฏ€๋กœ ด๋ฒˆžฅ๋ถ€„ฐ๋Š” ”„๋กœ๊ทธ๋žจ„ ๋‚˜๋ˆ „œ, „œ๋กœ ๋‹ค๋ฅธ ŒŒผ—  €žฅ, ปดŒŒผ•˜๋Š” ๋ฒ•๊ณผ, ๋‚˜ค‘— •ฉน˜๋Š” ๋ฒ• ๋“„ ๊ณต๋ถ€•  ๊ฒƒด๋‹ค.

2.1. 4.1 Organizing computations

  • 3žฅ๊นŒง€˜ ”„๋กœ๊ทธ๋žจ„ ๋ณด๋ฉด ๋“๊ธ‰„ ๋ฉ”๊ธฐ๋Š” ๋ถ€๋ถ„ด žˆ๋‹ค. ด ๋ถ€๋ถ„„ •จˆ˜๋กœ ถ”ถœ•ด๋ณดž. •จˆ˜๋กœ ถ”ถœ•จœผ๋กœจ, ๋‚˜ค‘— ๋˜‘๊ฐ™€ ๋‚ดšฉ„ ๋˜ ฝ”๋”ฉ•  •„š”๊ฐ€ —†๊ณ , •Œ•„๋ณด๊ธฐ๋„ ‰ฌ›Œ„๋‹ค. ๋˜•œ ๋“๊ธ‰ ๋ฉ”๊ธฐ๋Š” ๋ฐฉ๋ฒ•„ ๋ฐ”๊ฟ€๋•Œ ๊ทธ •จˆ˜ ๋ถ€๋ถ„—๋งŒ ๋ฌธ œ๋ฅผ •œ •ง€„ ˆ˜๊ฐ€ žˆ๋‹ค. ๋˜•œ •จˆ˜— ด๋ฆ„„ ง€–ดคŒœผ๋กœจ, ๋”š ถ”ƒ™”‹œ‚ฌˆ˜๊ฐ€ žˆ๊ฒŒ ๋œ๋‹ค.
  • •žžฅ—„œ ๋“๊ธ‰„ ถœ๋ ฅ•˜๋Š” ๋ถ€๋ถ„„ ‚ดŽด๋ณด๋ฉด,
    ~cpp 
    	cout << "Your final grade is " << setprecision(3)
    		<< 0.2 * midterm + 0.4 * final + 0.4 * median
    		<< setprecision(prec) << endl;
     
    ด๋ ‡๊ฒŒ ƒ๊ฒผ๋‹ค. ๋‘˜งธ„˜ ๋“๊ธ‰ ๊ณ„‚ฐ•˜๋Š” ๋ถ€๋ถ„„ ๋‹คŒ๊ณผ ๊ฐ™ด •จˆ˜๋กœ ๋ฝ‘•„๋‚ผ ˆ˜๊ฐ€ žˆ๋‹ค.
    ~cpp 
    double grade(double midterm, double final, double homework)
    {
        return 0.2 * midterm + 0.4 * final + 0.4 * homework;
    }
    /* ... */
    int main() 
    {
    /* ... */
    	cout << "Your final grade is " << setprecision(3)
    		<< grade(midterm, final, sum / count)
    		<< setprecision(prec) << endl;
    
    	return 0;
    }
    
     

  • •จˆ˜ ๋งŒ๋“œ๋Š” ๋ฒ•„ š”•ฝ•ด๋ณดž๋ฉด
    ~cpp 
    return_type function_name(parameter lists...) { •จˆ˜ ๋‚ด—„œ •  ผ๋“ค }
     
    ด๋ ‡๊ฒŒ •˜๋ฉด ๋œ๋‹ค.

  • •จˆ˜๋ฅผ ˜ธถœ• ๋•Œ—๋Š” •จˆ˜๋ฅผ ๋งŒ๋“ค๋•Œ ฃผ–ดกŒ๋˜ parameter lists๋ฅผ ถฉ‹œ‚ค๋Š” ๊ฐ’๋“ค„„–ดค˜•ผ •œ๋‹ค. ๋ฌผ๋ก  ˆœ„œ๋„ ๋งžถฐค˜•ผ •œ๋‹ค. arguments๋ผ๊ณ ๋„ •œ๋‹ค. arguments๋Š” ‹ด ๋ ˆ˜๋„ žˆ๋‹ค. ๊ทธ ๋’ค— •จˆ˜๋กœ ๋„˜–ด๊ฐ„ parameter๋“ค€ •จˆ˜ ๋‚ด—„œ ง€—ญ ๋ณ€ˆ˜(•จˆ˜๊ฐ€ ๋๋‚˜๋ฉด †Œ๋ฉธ๋˜๋Š”)ฒ˜๋Ÿผ ž‘๋™•˜๊ฒŒ ๋œ๋‹ค. ฆ‰ ๊ทธ ๊ฐ’๋“ค„ ๋ณต‚ฌ•˜๊ฒŒ ๋˜๋Š” ๊ฒƒด๋‹ค. ด๋ฅผ call by value๋ผ •œ๋‹ค.

  • 2.1.1. 4.1.1. Finding medians

  • •ž—„œ šฐ๋ฆฌ๋Š” vector— ๋“ค–ด๊ฐ€ žˆ๋Š” ๊ฐ’—„œ ค‘๊ฐ„๊ฐ’ ฐพ๋Š” ๊–ˆ—ˆ๋‹ค. Chapter8—„œ๋Š” vector— ๋“ค–ด๊ฐ€ žˆ๋Š” type— ๊ด€๊ณ„—†ด ž‘๋™•˜๊ฒŒ •˜๋Š” ๋ฒ•„ ๋ฐฐšธ ๊ฒƒด๋‹ค. ง€๊ธˆ€ vector<double>๋กœ๋งŒ •œ •ง“ž. median ๊ตฌ•˜๋Š” ๋ฃจ‹ด„ •จˆ˜๋กœ ๋นผ๋ณดž.
    ~cpp 
    double median(vector<double> vec)
    {
    	typedef vector<double>::size_type vec_sz;
    
    	vec_sz size = vec.size();
    	if (size == 0)
    		throw domain_error("median of an empty vector.");
    	
    	sort(vec.begin(), vec.end());
    	vec_sz mid = size/2;
    
    	return size % 2 == 0 ? (vec[mid] + vec[mid-1]) / 2 : vec[mid];
    }
     
  • —ฌ๊ธฐ„œ ‚ดŽด๋ณผ ๊ฒŒ ๋ช‡๊ฐ€ง€ žˆ๋‹ค. ง€๋‚œ๋ฒˆ—๋Š” vector˜ ฌ๊ธฐ๊ฐ€ 0ด๋ฉด ๊ทธ๋ƒฅ ”„๋กœ๊ทธ๋žจ„ ข…๋ฃŒ‹œผœ๋ฒ„๋ ธง€๋งŒ, —ฌ๊ธฐ„œ๋Š” ˜ˆ™ธฒ˜๋ฆฌ๋ผ๋Š” ‹ ๊ธฐˆ „ ‚ฌšฉ–ˆ๋‹ค. ด ๋ฐฉ๋ฒ•€ —ฌ๊ธฐ„œ ๋๋‚ดง€ •Š๊ณ  ๋‹คŒ ๋ถ€๋ถ„œผ๋กœ ๋„˜–ด๊ฐ„๋‹ค. <stdexcept>๋ฅผ ฌ•จ‹œผœ ฃผ๋ฉด ๋œ๋‹ค.
  • ๋˜•œ, •„๊นŒ •จˆ˜ ˜ธถœ•˜๋ฉด„œ parameter๋กœ ๋„˜๊ฒจ„๋•Œ—๋Š” ๊ทธ ๊ฐ’„ ๋ณต‚ฌ๋ฅผ •œ๋‹ค๊ณ  –ˆ๋‹ค.  €๋ ‡๊ฒŒ •จˆ˜๋ฅผ ˜ธถœ•จœผ๋กœจ, ›๋ž˜ vector๋ฅผ †ƒ‹œ‚คง€ •Š๊ณ , ๋ณต‚ฌ๋ณธ vector—„œ sort๋ฅผ •ด„œ ž‘—…„ ฒ˜๋ฆฌ•ด „ˆ˜๊ฐ€ žˆ๋‹ค. ๋น„๋ก ‹œ๊ฐ„ด ข€ ๋” ๊ธ๋ฆฌ๊ธด •˜ง€๋งŒ..

  • 2.1.2. 4.1.2 Reimplementing out grading policy

  • ดฏค ™€„œ •จˆ˜˜ œ šฉ•จ„ •Œ•˜๋‹ค๋ฉด, šฐ๋ฆฌ˜ „  ๋งค๊ธฐ๋Š” ๋ฐฉ๋ฒ•„ ๋”ฐ๋กœ •จˆ˜๋กœ ๋ฝ‘•„๋‚ด๊ณ  ‹ถ„ ๊ฒƒด๋‹ค. ๋‹คŒ ˜ˆ œ๋ฅผ ๋ณดž.
    ~cpp 
    double grade(double midterm, double final, const vector<double>& hw)
    {
    	if(hw.empty())		// …—„œ๋Š” hw.size()==0 ด๋ผ๊ณ  ๋˜–ด žˆง€๋งŒ 
    				// empty()๋ฉ”†Œ๋“œ๋ฅผ ˜ธถœ•˜๋Š” ๊ฒƒด ๋” šจœจ ด๋ผ๊ณ  •˜๋”๊ตฐš”.
    		throw domain_error("student has done no homework");
    	return grade(midterm, final, median(hw));
    }
     
  • —ฌ๊ธฐ„œ ๋ˆˆ—ฌ๊ฒจ๋ณผ „ธ๊ฐ€ง€ ‚ฌ•ญด žˆ๋‹ค.
    • const vector<double>& hw : ด๊ฒƒ„ šฐ๋ฆฌ๋Š” double˜• const vector๋กœ˜ ฐธกฐ๋ผ๊ณ  ๋ถ€๋ฅธ๋‹ค. reference๋ผ๋Š” ๊ฒƒ€ –ด๋– •œ ๊ฐฒด˜ ๋˜๋‹ค๋ฅธ ด๋ฆ„„ ๋ง•œ๋‹ค. ๋˜•œ const๋ฅผ ”€œผ๋กœจ,  € ๊ฐฒด๋ฅผ ๋ณ€๊ฒฝ•˜ง€ •Š๋Š”๋‹ค๋Š” ๊ฒƒ„ ๋ณดžฅ•ดค€๋‹ค. ๋˜•œ šฐ๋ฆฌ๋Š” reference๋ฅผ ”€œผ๋กœจ, ๊ทธ parameter๋ฅผ ๋ณต‚ฌ•˜ง€ •Š๋Š”๋‹ค. ฆ‰ parameter๊ฐ€ ปค๋‹ค๋ž€ ๊ฐฒดผ๋•Œ, ๊ทธ๊ฒƒ„ ๋ณต‚ฌ•จœผ๋กœจ ƒ๊ธฐ๋Š” overhead๋ฅผ —†•จˆ˜ žˆ๋Š” ๊ฒƒด๋‹ค.

  • ~cpp 
    vector<double> homework;
    vector<double>& hw = homework;
    // hw๋Š” homework™€ ๊ฐ™๋‹ค. ฆ‰, ด๋ฆ„€ ๋‹ค๋ฅดง€๋งŒ, hw๋ฅผ ๊ณ น˜๋ฉด homework๋„ ๊ฐ™ด ๊ณ ณ„๋‹ค. ™œ๋ƒ? ๊ฐ™œผ๋‹ˆ๊นŒ
     
    • grade() function : šฐ๋ฆฌ๋Š” •„๊นŒ grade๋ผ๋Š” •จˆ˜๋ฅผ ๋งŒ๋“ค—ˆ—ˆ๋‹ค. ๊ทธ๋Ÿฐ๋ฐ ด๋ฒˆ— ด๋ฆ„€ ๊ฐ™œผ๋ฉด„œ parameter๋Š” กฐ๊ธˆ ๋‹ค๋ฅธ grade()๋ฅผ ๋˜ ๋งŒ๋“ค—ˆ๋‹ค. ด๋Ÿฐ๊ฒŒ ๊ฐ€๋Šฅ•œ๊ฐ€? ๊ฐ€๋Šฅ•˜๋‹ค. ด๋Ÿฌ•œ ๊ฒƒ„ •จˆ˜˜ overloadingด๋ผ๊ณ  •œ๋‹ค. •จˆ˜ ˜ธถœ• ๋•Œ –ด๋–ค๊ฒŒ ˜ธถœ๋ ๊นŒ๋Š” ๋”ฐ๋ผ๊ฐ€๋Š” parameter lists— ˜•ด ๊ฒฐ •๋œ๋‹ค.
    • exception : ‚ฌšฉž—๊ฒŒ ๋ฌด—‡ด ž˜๋ชป๋˜—ˆ๋Š”๊ฐ€๋ฅผ •Œ๋ คฃผ๋Š” exception„ ๋˜ ธค€๋‹ค.

    2.1.3. 4.1.3 Reading homework grades

  • ด œ šฐ๋ฆฌ๊ฐ€ ’€–ด•ผ •  ๋ฌธ œ๋Š”, ˆ™ œ˜ ๋“๊ธ‰„ vector๋กœ ฝ–ด๋“คด๋Š” ๊ฒƒด๋‹ค. —ฌ๊ธฐ—๋Š” ๋‘๊ฐ€ง€˜ ๋ฌธ œ ด žˆ๋‹ค. ๋ฐ”๋กœ ๋ฆฌ„ด๊ฐ’ด ๋‘๊ฐœ—ฌ•ผ •œ๋‹ค๋Š”  ด๋‹ค. •˜๋‚˜๋Š” ฝ–ด๋“คธ ๋“๊ธ‰๋“คด๊ณ , ๋˜ ๋‹ค๋ฅธ •˜๋‚˜๋Š” ๊ทธ๊ฒƒด „๊ณต–ˆ๋‚˜ •˜๋Š”๊ฐ€ด๋‹ค. •˜๋‚˜˜ ๋Œ€•ˆด žˆ๋‹ค. ๋ฐ”๋กœ ๋ฆฌ„•˜๊ณ ž •˜๋Š” ๊ฐ’„ ๋ฆฌ„•˜ง€ ๋ง๊ณ , ๊ทธ๊ฒƒ„ reference๋กœ ๋„˜๊ฒจ„œ ๋ณ€๊ฒฝ•ดฃผ๋Š” ๋ฒ•ด๋‹ค. const๋ฅผ ๋ถ™ดง€ •Š€ reference๋Š” ”žˆ ๊ทธ ๊ฐ’„ ๋ณ€๊ฒฝ• ๋•Œ “ฐธ๋‹ค. reference๋กœ ๋„˜–ด๊ฐ€๋Š” ๊ฐ’„ ๋ณ€๊ฒฝ•ด•ผ •˜๋ฏ€๋กœ –ด๋–ค ‹(expression)ด reference๋กœ ๋„˜–ด๊ฐ€๋ฉด •ˆ๋œ๋‹ค.(lvalue๊ฐ€ •„๋‹ˆ๋ผ๊ณ ๋„ •œ๋‹ค. lvalue๋ž€ ž„‹œ ธ ๊ฐฒด๊ฐ€ •„๋‹Œ ๊ฐฒด๋ฅผ ๋ง•œ๋‹ค.)
    ~cpp 
    istream& read_hw(istream& in, vector<double>& hw)
    {
    	double x;
    	while(in >> x)				// ฐจฐจ ‚ดŽด๋ณผ…Œง€๋งŒ ด๊ž˜๋ชป๋˜—ˆ๋‹ค.
    		hw.push_back(x);
    }
    
    read_hw(cin, homework);	// ˜ธถœ
     
  • œ„—„œ ž˜๋ชป๋œ ๋ถ€๋ถ„„ ฐพ•„๋ณดž.
    • hw๊ฐ€ ๋„˜–ด˜ค๋ฉด„œ hw•ˆ— •„๋ฌด๊ฒƒ๋„ —†๋‹ค๋Š” ๊ฒƒ„ ๋ณดžฅ• ˆ˜ žˆ๊ฒ ๋Š”๊ฐ€? ๋จผ €๋ฒˆ— “ฐ๋˜ •™ƒ๋“ค˜  ˆ˜๊ฐ€ ๋“ค–ดžˆ„ง€๋„ ๋ชจ๋ฅธ๋‹ค. ™•‹ค•˜๊ฒŒ —†• ฃผ๊ธฐ œ„•ด hw.clear()๋ฅผ •ดฃผž.
    •  € while ๋ฃจ”„๊ฐ€ –ธ œ ๋ฉˆถœง€ •Œˆ˜ žˆ๋Š”๊ฐ€? ŒŒผ˜ ๋— ๋„๋‹ฌ–ˆฐ๋‚˜, ž…๋ ฅ๋ฐ›€๊ฒŒ ๋“๊ธ‰ด •„๋‹๋•Œผ ๊ฒƒด๋‹ค.
      • ŒŒผ˜ ๋— ๋„๋‹ฌ–ˆ๋‹ค๋Š” ๊ฒƒ = ฝ๊ธฐ ‹คŒจ
      • ž…๋ ฅ๋ฐ›€๊ฒŒ ๋“๊ธ‰ด •„๋‹๋•Œ( ˆ˜๋ฅผ ž…๋ ฅ•ด•ผ ๋˜๋Š”๋ฐ ดƒ•œ ๊ฒƒ„ ž…๋ ฅ–ˆ„๋•Œ) istream ๊ฐฒด in€ ‹คŒจ ƒƒœ๊ฐ€ ๋œ๋‹ค. ๋˜•œ ๊ทธ๊ฒƒ„ ฝง€ •Š๋Š”๋‹ค. ŒŒผ˜ ๋— ๋„๋‹ฌ•œ๊ฒƒ ฒ˜๋Ÿผ...
    • ด ƒ™ฉ„ •ด๊ฒฐ•˜๊ธฐ œ„•ด, ๊ทธ๋ƒฅ in๊ฐฒด˜ ƒƒœ๋ฅผ ˆ๊ธฐ™”•ดค˜๋ฒ„๋ฆฌž. in.clear() ๋ชจ๋“  —๋Ÿฌ ƒƒœ๋ฅผ ๋ฆฌ…‹‹œผœค€๋‹ค.

  • ~cpp 
    istream& read_hw(istream& in, vector<double>& hw)
    {
    	if(in)
    	{
    		hw.clear();
    		double x;
    		while(in >> x)
    			hw.push_back(x);
    		in.clear();
    	}
    	return in;
    }
     
    DeleteMe) ๋‘๋ฒˆงธ๊ฐ€ ž˜ ด•ด๊ฐ€ •ˆ๊ฐ€๋„ค.. ๋ˆ„๊ฐ€ ž˜ •„‹œ๋Š” ๋ถ„€ ๋ช…พŒ•œ „ค๋ช… ๋ถ€ƒ๋“œ๋ฆฝ๋‹ˆ๋‹ค.

    2.1.4. 4.1.4 Three kinds of function parameters

  • ง€๊ธˆ๊นŒง€ ๋งŒ๋“  „ธ๊ฐœ˜ •จˆ˜ median, grade, read_hw ๋ฅผ ‚ดŽด๋ณดž.
    • median •จˆ˜๋ฅผ ๋ณด๋ฉด, vector<double> ŒŒ๋ผ๋ฉ”„ฐ๊ฐ€ ฐธกฐ๋กœ ๋„˜–ด๊ฐ€ง€ •Š๋Š”๋‹ค. •™ƒˆ˜๊ฐ€ ๋งŽ•„ˆˆ˜๋ก ๋งคšฐ ฐ ๊ฐฒด๊ฐ€ ๋ …๋ฐ ๋‚ญ๋น„๊ฐ€ •„๋‹Œ๊ฐ€? •˜๊ณ  ƒ๊ฐ• ˆ˜๋„ žˆง€๋งŒ, –ดฉ”ˆ˜ —†๋‹ค. •จˆ˜ ๋‚ด๋ถ€—„œ †ŒŒ…„ •ด๋ฒ„๋ฆฌ๊ธฐ ๋•Œ๋ฌธ— ฐธกฐ๋กœ ๋„˜๊ธฐ๋ฉด, ปจ…Œด๋„ˆ˜ ƒƒœ๊ฐ€ ๋ณ€•ด๋ฒ„๋ฆฐ๋‹ค.
    • grade •จˆ˜๋ฅผ ๋ณด๋ฉด, vector๋Š” const ฐธกฐ๋กœ ๋„˜๊ธฐ๊ณ , double€ ๊ทธ๋ ‡ง€ •Š๋‹ค. int๋‚˜ double๊ฐ™€ ๊ธฐ๋ณธ˜•€ ฌ๊ธฐ๊ฐ€ ž‘๊ธฐ ๋•Œ๋ฌธ—, ๊ทธ๋ƒฅ ๋ณต‚ฌ๋กœ ๋„˜๊ฒจ๋„ ถฉ๋ถ„žˆ ๋น ๋ฅด๋‹ค. ๋ญ ๊ฐ’„ ๋ณ€๊ฒฝ•ด•ผ • ๋•Œ๋ผ๋ฉด ฐธกฐ๋กœ ๋„˜๊ฒจ•ผ๊ฒ ง€๋งŒ... const ฐธกฐ๋Š” ๊ฐ€žฅ ผ๋ฐ˜ ธ  „๋‹ฌ๋ฐฉ‹ด๋‹ค.
    • read_hw •จˆ˜๋ฅผ ๋ณด๋ฉด, ๋ณต‚ฌ๋Š” •˜ง€ •Š๊ณ , ๊ทธ ๊ฐ’„ ๋ณ€๊ฒฝ•˜๊ธฐ œ„•ด ฐธกฐ๋งŒ ผ๋‹ค.
  • const๊ฐ€ •„๋‹Œ ฐธกฐ˜• ŒŒ๋ผ๋ฉ”„ฐ๋Š” lvalue—ฌ•ผ๋งŒ •œ๋‹ค.

  • 2.1.5. 4.1.5 Using functions to calculate a student's grade

  • †ŒŠค๋ฅผ ๋ณด๋ฉด ƒˆ๋กœšด๊ฒŒ ๋ˆˆ— ๋ˆ๋‹ค. ๋ฐ”๋กœ tryด๋‹ค. ๋‹คŒ๊ณผ ๊ฐ™ด “ด๋‹ค.
    ~cpp 
    	try {
    		// •˜๋‹ค๊ฐ€ ˜ˆ™ธ ๋ฐœƒ•˜๋ฉด, ค‘๋‹จ•˜๊ณ 
    	}
    	catch(domain_error) {
    		// ด๋ฆฌ๋กœ ˜จ๋‹ค. ๋งŒ•ฝ— try •ˆ—„œ ˜ˆ™ธ •ˆ ๋œจ๋ฉด catch •ˆ€ ˆ˜–‰•ˆ•œ๋‹ค.
    	}
     

  • —ฌ๊ธฐ๊นŒง€ ตœข…†ŒŠค

    ~cpp 
    #include <ios>
    #include <iomanip>
    #include <iostream>
    #include <string>
    #include <vector>
    #include <algorithm>
    #include <stdexcept>
    
    using namespace std;
    
    double grade(double midterm, double final, double homework);
    double grade(double midterm, double final, const vector<double>& hw);
    double median(vector<double> vec);
    istream& read_hw(istream& in, vector<double>& hw);
    
    int main()
    {
    	cout << "Please enter your first name: ";
    	string name;
    	cin >> name;
    	cout << "Hello, " << name << "!";
    
    	cout << "Please enter your midterm and final exam grades: ";
    	double midterm, final;
    	cin >> midterm >> final;
    
    	cout << "Enter all your homework grades, "
    			"follewd by end-of-file: ";
    
    	vector<double> homework;
    
    	read_hw(cin, homework);
    
    	try
    	{
    		double final_grade = grade(midterm, final, homework);
    
    		streamsize prec = cout.precision();
    		cout << "Your final grade is " << setprecision(3)
    			<< final_grade << setprecision(prec) << endl;
    	}
    	catch(domain_error)
    	{
    		cout << endl << "You must enter your grades. "
    			"Please try again." << endl;
    		return 1;
    	}
    
    	return 0;
    }
    
    double grade(double midterm, double final, double homework)
    {
    	return 0.2 * midterm + 0.4 * final + 0.4 * homework;
    }
    
    double grade(double midterm, double final, const vector<double>& hw)
    {
    	if(hw.size() == 0)
    		throw domain_error("Student has done no homework");
    
    	return grade(midterm, final, median(hw));
    }
    
    double median(vector<double> vec)
    {
    	typedef vector<double>::size_type vec_sz; 
    
    	vec_sz size = vec.size();
    
    	if(size == 0)
    		throw domain_error("median of an empty vector");
    
    	sort(vec.begin(),vec.end());
    
    	vec_sz mid = size / 2;
    
    	return size % 2 == 0 ? (vec[mid] + vec[mid-1]) / 2 : vec[mid];
    }
    
    istream& read_hw(istream& in, vector<double>& hw)
    {
    	if(in)
    	{
    		hw.clear();
    
    		double x;
    		while(in >> x)
    			hw.push_back(x);
    
    		in.clear();
    	}
    	return in;
    }
    

    2.2. 4.2 Organizing data

    • —ฌƒœ๊นŒง€๋Š” •œ •™ƒ˜ ๋ฐด„ฐ๋งŒ ๊ฐ€ง€๊ณ  ๋†€•˜๋‹ค. •˜ง€๋งŒ „  ฒ˜๋ฆฌ ”„๋กœ๊ทธ๋žจ€, ๋ชจ๋“  •™ƒ˜ ๋ฐด„ฐ๋ฅผ ๋Œ€ƒœผ๋กœ •œ๋‹ค. ด— ๋‹ค‹œ ฒด๊ณ„ ธ ๋ฐด„ฐ ๊ตฌกฐ๊ฐ€ •„š”•˜๋‹ค.

    2.2.1. 4.2.1 Keeping all of a student's data together

  • •™ƒ˜ ๋ฐด„ฐ๋ฅผ ๋ฌถ–ด ๋ณดž. —ฌ๊ธฐ„œ struct๋ž€ ƒˆ๋กœšด ๊ตฌ๋ฌธด ๋‚˜˜จ๋‹ค. {}•ˆ— ๋ฉค๋ฒ„๋กœ ๋„ฃ๊ณ  ‹ถ€ ๋ณ€ˆ˜๋“ค„ ซ™ จฃผ๋ฉด ๋œ๋‹ค.  ‘๊ทผ• ๋ผ๋ฉด . จฃผ๊ณ  ๋ณ€ˆ˜ “ฐ๋ฉด ๋œ๋‹ค.
    ~cpp 
    struct Student_info {
    	string name;
    	double midterm, final;
    	vector<double> homework;
    };
     
  • ๋ฐด„ฐ ๊ตฌกฐ๊ฐ€ ๋ฐ”๋€Œ—ˆœผ๋‹ˆ, šฐ๋ฆฌ˜ ”„๋กœ๊ทธ๋žจ๋„ •ฝ๊ฐ„ ๋ณ€๊ฒฝ„ •ด•ผ•  ๊ฒƒด๋‹ค. ๋จผ € read
    ~cpp 
    istream& read(istream& is, Student_info& s)
    {
    	is >> s.name >> s.midterm >> s.final;
    	read_hw(is, s.homework);
    	return is;
    }
     
    • is >> „ ๋ณด๋ฉด, string„ ฝ—ˆ๋‹ค๊ฐ€ double„ ฝ๊ธฐ๋„ •œ๋‹ค. ด๊ฒŒ ๊ฐ€๋Šฅ•œ ดœ ๋Š” ˜ค๋ฒ„๋กœ๋”ฉ ๋•Œ๋ฌธด๋‹ค.
    • Student_info˜• ๋ณ€ˆ˜ s˜ ๊ฐ’„ ๋ณ€๊ฒฝ‹œ‚ค๊ธฐ œ„•ด ฐธกฐ๋กœ ๋„˜๊ฒจคฌ๋‹ค.
  • ๋‹คŒ—” grade. ˜›๋‚  ๋ฒ„ ผ€ ธž๋กœ midterm, final, homework๋“„ ๋ฐ›•˜ง€๋งŒ, ˜ค๋ฒ„๋กœ๋”ฉ„ ดšฉ•ด„œ, Student_info •˜๋‚˜๋งŒ„ ๋ฐ›๋„๋ก •ด๋ณดž.
    ~cpp 
    double grade(const Student_info& s)
    {
    	return grade(s.midterm, s.final, s.homework);
    }
     
  • ๋งˆง€๋ง‰œผ๋กœ sort. šฐ๋ฆฌ๋Š” ๋‹คŒ๊ณผ ๊ฐ™ด –ˆ—ˆ๋‹ค.
    ~cpp 
    sort(vec.begin(), vec.end());
     
    •  € vec€ double˜• ๊ฐ’„ ๋‹ด๊ณ  žˆ—ˆ๊ธฐ 떄๋ฌธ—, ˆœ„œ๋Œ€๋กœ sort•˜๋ฉด ๋˜—ˆ—ˆ๋‹ค. •˜ง€๋งŒ šฐ๋ฆฌ๊ฐ€ ๋งŒ๋“  Student_info๋Š” –ด๋–ป๊ฒŒ sort๋ฅผ • ๊นŒ?

  • ~cpp 
    sort(students.begin(), students.end());       // ๊ณผ—ฐ? #!$%#@^#@$#
     
    • ๋ฌด—‡„ ๊ธฐค€œผ๋กœ sort๋ฅผ • ๊ฒƒธ๊ฐ€? ด๋ฆ„? midterm? final? •Œˆ˜๊ฐ€ —†๋‹ค. ๋”ฐ๋ผ„œ šฐ๋ฆฌ๋Š” predicate๋ผ๋Š” ๊ฒƒ„  •˜•ด ฃผ–ด•ผ •œ๋‹ค. ๋‹คŒ๊ณผ ๊ฐ™ด •ดฃผ๋ฉด ๋œ๋‹ค.

    ~cpp 
    bool compare(const Student_info& x, const Student_info& y)
    {
    	return x.name < y.name;
    }
    
    sort(students.begin(), students.end(), compare);
     

    2.2.2. 4.2.3. Generating the report

  • max(๊ฐ™€ ƒ€ž…˜ ŒŒ๋ผ๋ฉ”„ฐ ๋‘๊ฐœ) : ๋ญ ฐ๊ฐ’„ ๋ฆฌ„•ด ฃผ๊ฒ ง€
  • string(๊ธธด,'๋ฌธž') : ๊ธธด๋งŒผ˜ '๋ฌธž'๋ฅผ ƒ„•ดค€๋‹ค.
  • catch(domain_error e) •œ ๋‹คŒ— ๋ฌดŠจ ˜ˆ™ธ ๋‚ฌ๋Š”ง€ •Œ๊ณ  ‹ถœผ๋ฉด e.what()„ •ดค€๋‹ค.

  • 2.3. 4.3. Putting it all together

  • ๋ถ„๋ฆฌ ปดŒŒผด๋ž‘ —ค๋” ŒŒผ ด•ผ๊ธฐ ๋‚˜˜จ๋‹ค. ๊ทธ๋ƒฅ ๋„˜–ด๊ฐ€ž.
  • —ค๋” ŒŒผ—„œ๋Š” using namespace ด๋Ÿฐ๊“ฐง€ ๋ง๊ณ  ๊ทธ๋ƒฅ ’€ ๋„ž„ จฃผž. std:vector ด๋ ‡๊ฒŒ...
  • ๋‘๋ฒˆ ดƒ ฌ•จ๋˜๋Š” ๊ฒƒ„ ๋ฐฉง€ •˜๊ธฐ œ„•ด, #ifndef, #define, #endif ด๋Ÿฐ๊•ดฃผž. ๊ทธ๋Ÿฌ๋ฉด„œ  „ฒ˜๋ฆฌ๊ธฐ ด•ผ๊ธฐ๊ฐ€ ๋‚˜˜จ๋‹ค.
    ~cpp 
    #ifndef GURAD
    #define GUARD
    /* ...
       ...
       ... */
    #endif
     

  • 2.4. 4.4. Partitioning the grading program

  • ๊ทธ๋ƒฅ ชผ๊ฐœ๋Š” ๊ฐ๋‹ค.

  • 2.5. 4.5. The revised grading program

  • ๊ทธ๋ƒฅ ๋ณด๊ธฐ ข‹•„กŒ๋‹ค๋Š” –˜๊ธฐ•˜๊ณ  žˆ๋‹ค.


  • Valid XHTML 1.0! Valid CSS! powered by MoniWiki
    last modified 2021-02-07 05:22:25
    Processing time 0.0299 sec