[c++] 面向对象课程（三）-- 面向对象模型

导读

• 模板/泛型，面向对象是C++的两大思路
• STL主要用模板/泛型

 C++OOP2-ex.cpp

// author : Hou Jie
// date : 2015/11/27
// compiler : DevC++ 5.11 (MinGW with GNU 4.9.2)
// course : C++OOP2

using namespace std;

//-------------------------------------------------------------
#include <string>
#include <iostream>
#include <memory> //shared_ptr

namespace jj01
{
class Base1 {  };
class Derived1: public Base1 {  };    
class Base2 {  };
class Derived2: public Base2 {  };

    
template <class T1, class T2>
struct pair {
  typedef T1 first_type;
  typedef T2 second_type;

  T1 first;
  T2 second;
  pair() : first(T1()), second(T2()) {}
  pair(const T1& a, const T2& b) : first(a), second(b) {}

  template <class U1, class U2>
  pair(const pair<U1, U2>& p) : first(p.first), second(p.second) {}
};

void test_member_template()
{
    cout << "test_member_template()" << endl;
    pair<Derived1, Derived2> p; 
    pair<Base1, Base2> p2(pair<Derived1, Derived2>());     
    pair<Base1, Base2> p3(p);   
        //Derived1 will be assigned to Base1; Derived2 will be assigned to Base2.
        //OO allow such assignments since of "is-a" relationship between them.  
        
//!    pair<Derived1, Derived2> p4(p3);
        //error messages as below appear at the ctor statements of pair member template
        // [Error] no matching function for call to 'Derived1::Derived1(const Base1&)'
        // [Error] no matching function for call to 'Derived2::Derived2(const Base2&)'        
        
    Base1* ptr = new Derived1;     //up-cast 
    shared_ptr<Base1> sptr(new Derived1);     //simulate up-cast
        //Note: make sure your environment support C++2.0 at first.
}
} //namespace
//-------------------------------------------------------------
#include <string>
#include <iostream>
#include <list>
namespace jj02
{
template<typename T,  
         template <typename T>  
             class Container 
        > 
class XCls 
{  
private:
      Container<T> c; 
public:
    XCls() 
    {                             
        for(long i=0; i< 100; ++i)         
            c.insert(c.end(), T());            
    }
};

template<typename T>
using Lst = list<T, allocator<T>>;   //Note: make sure your environment support C++2.0

void test_template_template_parameters_1()
{
    cout << "test_template_template_parameters_1()" << endl;
    
//!    XCls<string, list> mylist;
            //[Error] expected a template of type 'template<class T> class Container', got 'template<class _Tp, class _Alloc> class std::list'
    XCls<string, Lst> mylist;        //Note: make sure your environment support C++2.0
}
} //namespace
//-------------------------------------------------------------
#include <string>
#include <iostream>
#include <memory> //smart pointers
namespace jj03
{
template<typename T,  
         template <typename T>  
             class SmartPtr 
        > 
class XCls 
{  
private:
      SmartPtr<T> sp; 
public:
    XCls() : sp(new T)  { }
};

void test_template_template_parameters_2()
{
    cout << "test_template_template_parameters_2()" << endl;
    
    XCls<string, shared_ptr> p1;       //Note: make sure your environment support C++2.0
    XCls<double, auto_ptr> p4;    
//!    XCls<double, unique_ptr> p2;      //unique_ptr has two template parameters 
//!    XCls<int, weak_ptr> p3;            //[Error] no matching function for call to 'std::weak_ptr<int>::weak_ptr(int*)'
}
} //namespace
//-------------------------------------------------------------
#include <iostream>
namespace jj04
{    
    
void test_object_model()
{    
    cout << "test_object_model()" << endl;

}
} //namespace 
//-------------------------------------------------------------
#include <iostream>
namespace jj05
{    
class Fraction
{
public:
    explicit Fraction(int num, int den=1) 
      : m_numerator(num), m_denominator(den)
    { cout << m_numerator << ' ' << m_denominator << endl; }
    
     operator double() const { 
      return (double)m_numerator / m_denominator; 
     }
     
     Fraction operator+(const Fraction& f) {  
       cout << "operator+(): " << f.m_numerator << ' ' << f.m_denominator <<  endl;  
       //... plus
       return f; 
    } 
/*    
    Fraction(double d) 
      : m_numerator(d * 1000), m_denominator(1000) 
    { cout << m_numerator << ' ' << m_denominator << endl; }
*/

private:   
   int m_numerator;    //
   int m_denominator;  //
};
    
void test_conversion_functions()
{    
    cout << "test_conversion_functions()" << endl;
    
    Fraction f(3,5);
    
    double d = 4 + f;        //4.6
    cout << d << endl;
    
    //! Fraction d2 = f + 4;     //ambiguous        
}
} //namespace 
//-------------------------------------------------------------
#include <iostream>
namespace jj06
{    
void test_reference()
{    
    cout << "test_reference()" << endl;

    {
    int x=0;
    int* p = &x;
    int& r = x;       //r is a reference to x. now r==x==0
    int x2=5;
    r = x2;          //r cannot re-reference to another. now r==x==5
    int& r2 = r;     //now r2==5 (r2 is a reference to r, i.e. a reference to x)    
    }
    
    
    {
    typedef struct Stag { int a,b,c,d; } S;

    double x=0;
    double* p = &x;     //p is a pointer to x. p's value is same as x's address.
    double& r = x;         //r is a reference to x, now r==x==0
    
    cout << sizeof(x) << endl;     //8
    cout << sizeof(p) << endl;     //4
    cout << sizeof(r) << endl;     //8
    cout << p << endl;             //0065FDFC
    cout << *p << endl;         //0
    cout << x << endl;             //0
    cout << r << endl;             //0
    cout << &x << endl;         //0065FDFC
    cout << &r << endl;         //0065FDFC
    
    S s;
    S& rs = s;
    cout << sizeof(s) << endl;     //16
    cout << sizeof(rs) << endl; //16
    cout << &s << endl;         //0065FDE8
    cout << &rs << endl;         //0065FDE8    
     }
}
} //namespace 
//-------------------------------------------------------------
int main(int argc, char** argv) 
{
    std::cout << __cplusplus << endl;    //199711 or 201103
    
    jj01::test_member_template();    
    jj02::test_template_template_parameters_1();    
    jj03::test_template_template_parameters_2();
    jj04::test_object_model();        
    jj05::test_conversion_functions();
    jj06::test_reference();    
}

 conversion function 转换函数

• 在运算时自动调用，把Fraction转为double
• 138：没有返回类型，用double()表示
• 139：double应写在后面的括号里，或者后面的括号不写
• 164：调用operator double() 将 f 转为0.6
• 《C++ Primer》 P514

#include<iostream>
using namespace std;

class Complex{
    public:
        Complex():m_real(0.0),m_imag(0.0){}
        Complex(double real,double imag):m_real(real),m_imag(imag){}
        Complex(double real):m_real(real),m_imag(0.0){} //转换构造函数 
    public:
        friend ostream& operator << (ostream& out,Complex& c); //重载运算符 
    private:
        double m_real;
        double m_imag;
};

ostream & operator<<(ostream &out, Complex &c){
    out<<c.m_real<<"+"<<c.m_imag<<"i";
    return out;
}

int main(){
    Complex a = 25.5;
    Complex b(10.0,20.0);
    cout<<a<<endl; 
    cout<<b<<endl; 
    return 0;
}

参考

C++转换函数

http://c.biancheng.net/view/2340.html