class complex
{
public:
double real() const
{return this->re;}//this 可写可不写
private:
double re,im;
}
complex c1,c2
cout<<c1.real(); //complex::real(&c1)
cout<<c2.real(); //complex::read(&c2)
-
static 类成员元素
多个object只有一份数据 -
static 类成员函数
静态函数没有this指针，只用于访问静态成员元素
class Account {
public：
static double m_rate;
static void set_rate(const double& x) {m_rate = x ;}
};
double Account::m_rate = 8.0
int main(){
Account::set_rate(5.0);//class name调用
Account a;
a.set_rate(7.0);//通过object调用
}
- 单例 singleton
class A {
public:
static A& getInstance(){static A a;return a;}
setup(){...}
private:
A();
A(const A& rhs);
}
- class template
template<typename T>
class complex
{
public:
complex(T r=0,T i=0)
: re(r),im(i)
{}
complex& operator += (const complex&)
T real() const{return re;}
T imag() const{return im;}
private:
T re,im;
friend complex& __doapl(complex*,const complex&);
}
{
complex<double> c1(1.0,2.0);
}
- funcation template
template <class T> //typename关键之是一样的
inline
const T& min(const T& a, const T& b)
{
return b<a?b:a;//如果不是内建类型，这里需要用到类的操作符重载小于符号
}
函数模板不需要明确指出类型，会做argument deduction(实参推到)
- namespace
主要用于避免多个同名的类 函数 等同名
a.cpp b.cpp
namespace std namespace std
{ {
.. ...
} }
可以写到多个文件里面
#inlcude<iostream.h>
using namespace std; //using directive
int main()
{
cin<<..;
cout<<..;
return 0
}
#include<iostream.h>
using std::out //using declaration
int main()
{
std::cin<<...;
cout<<...;
retun 0
}
operator type() const
explicit
template specialization
inheritance(继承)
composition(复合)
delegation(委托)
- composition(复合) has-a
queue |--->deque
Adapter 适配器
template<class T>
class queue{ //Adapter 适配器 deque 功能已经很强大，queue只需要开放其中一部分功能
...
protected:
deque<T> c; //底层容器
public:
//以下完全利用c的操作函数完成
bool empty() const{return c.empty();}
size_type size() const {return c.size();}
reference fron(){return c.front();}
//
void push(const value_type&x){c.push_back(x);}
void pop(){c.pop_front();}
}
- composition(符合)下的构造和析构
container|--->component
- 构造由内而外
container的够着函数首先调用component的default够着函数
然后才执行自己的。
Container::Container(...):component(){...};
————————————
这部分是编译器
自己加的
- 析构由外到内
container的析构函数首先执行自己，然后才调用component的
析构函数。
container::~container{..~component()};
———————————
编辑以自己加
的
- delegation(委托).composition by reference
class string{
public：
string();
string(const char* s);
string(const string& s);
string &operator=(const string& s);
~string();
...
private:
stringRep* rep;//pimpl 委托指针
}
string --->stringrep
- inheritance(继承),is-a
struct _List_node_base
{
_List_node_base* _M_next;
_List_node_base* _M_prev;
};
template<typename _Tp>
struct _List_node: public _List_node_base
{
_Tp _M_data;
};
__List_node_base
/\
|
|
_List_node
- inheritance(继承)关系下的的构造和析构
base --->基类的析构函数必须是virtual，
/\
|
|
derived
- 构造由内而外
derived的构造函数首先调用base的default构造函数
然后执行自己
derived::derived(...):base(){....};
- 析构函数由外到内
derived的析构函数先执行，然后调用base的析构函数。
注意要写virtual
derived::derived(...){...~base()};
- 虚函数和多态
inheritance with vritual funcations
- no-virtual函数：你不希望derived class重新定义(override)它
- vitural函数：你希望derived class重新定义(overriade，重写)它，它已经有自己的定义
- pure virtual函数：你希望derived class 一定要重写它(overrade),没有默认定义
class shape{
public：
virtual void draw() const=0;
virtual void error(const std::string& msg);
int objectid() const;
...
}
- Template method 非常重要
cdocument::serialize为一个纯虚函数
cdocument::
onfileopen()
{
...
serialize()
...
}
class cmydoc:public cdocument
{
virtual serialize(){...}
}
main()
{
cmydoc mydoc;
mydoc.onfileopen()
}
实际测试代码：
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
class base
{
public:
virtual void base_1() const
{
cout<<"in base"<<endl;
}
void process() const
{
cout<<"test in base begin"<<endl;
base_1();//框架写好了，子函数实现
cout<<"test in base end"<<endl;
}
};
class myclass:public base
{
public:
void base_1() const //virtual 可写可不写
{
cout<<"in myclass"<<endl;
}
};
int main()
{
//method 1:template method
//base_1方法子类做了重新定义
myclass my; //定义一个子类对象
my.process();//实际上做this->process 然后this->base_1,vptr指针
//method 2:父类指针指向子类对象
base* test = &my;
test->base_1();
//父类自己的实现
base mybase;
mybase.process();
}
结果为：
test in base begin
in myclass
test in base end
in myclass
test in base begin
in base
test in base end
- component+inheritnce
base(1)
|
|
derived(3) |--->component(2)
构造谁再前？已经标号
base(2) |--->component(1)
|
|
derived(3)
构造谁再前？已经标号
- 观察者 delegation + inheritance
n
subject---->observer
|
|
具体的obs
class subject
{
int m_value;
vetor<observer*>m_views;
public:
void attach(observer* obs)
{
m_views.push_back(obs);
}
void set_val(int value)
{
m_value=value;
notify();
}
void notify()
{
for(int i=0;i<m_view.size();++i)
m_view[i]->update(this,m_value);
}
}
class observer
{
public:
virtual void update(subject* sub,int value) = 0;
}
const 函数，指定this中的对象不能更改
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
class base{
public:
int* p;
base():p(NULL)
{}
~base()
{
free(p);
}
};
class test{
public:
base* p;
const int t;
test():t(1)
{
p = new base();
}
void change() const
{
(this->p)->p = new int(4); //只要不改变this->p的值即可，指向对象的值可以更改
cout<<*((this->p)->p)<<endl;
}
~test()
{
delete p;
}
};
int main()
{
test a;
a.change();
base b;
}
网友评论