C++4

类和对象

1，类的定义

class CTest

{

private:

int private_data;

void private_method()

{

cout<<endl;

}

protected:

int protectd_data;

void protected_method()

{

cout<<endl;

}

public:

int public_data;

void public_method()

{

cout<<endl;

}

void Init()

{

private_data=0;

protectd_data=1;

publicdata=2;

}

};

void main90

{

cTest c;

c.Init();

};

在类的外部不能访问类的私有成员和保护成员；

在类的外部定义成员函数

void Cs::PrintInfo()

{

cout<<endl;

};

对象定义和访问

Cs s1;

si.Printlion();

4,this指针

void CStudent::SetID(int id)

{

this->id=id;

}

5构造函数

class a

{

private:

int id;

char name[20];

float fScore;

public:

a();//构造函数

a(int id,char name,float fScore);//重载构造函数

~a();//析造函数

void printInfo();

}

不声明构造函数，自动定义缺省构造函数才，析造函数是最早构造函数它最后出，一个类只有一个析造函数。拷贝构造函数要在类中声明拷贝构造函数

CStudent(Cstudent &s);

CStudent(Cstudent &s)

{id=s.id;

}

7对象和指针

void main()

{

CStudent s;

CStudent *ps;

ps=&s;

ps->SteINft(1,"asa",92);

}

8常对象和常成员

常对象不能被改变，因此必须在定义是进行初始化

类名 const 对象名

const  类名 对象名

const A  a(1,2);

常成员

类型 函数名（形参） const;

可以读取数据成员的值，但不能改变不能调用没const的成员

1，静态数据成员static 是对象共享的数据成员，静态成员函数不为谋一对性服务，是共享的

2.友元是以个外部函数

class p

{private:

int x,y;

public:

P(int x,int y)

{

this->x=x;this->y=y;

}

friend double dist (p&p1,P  &p2);

}

double dist(p &p1,p &p2)

{

return sqrt (double (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y))

}

运算符重载关键字operator

a a::operator+(a&c)

{

a temp;

temp.x=x+c.x;

temp.y=y+c.y;

}

 

#include <iostream> 
using namespace std; 
 
class Base 
{ 
    public://公有的 
        int a1; 
        virtual void test() = 0; 
    protected://受保护的 
        int a2; 
    private://私有的 
        int a3; 
}; 
//------------------------------------------------------------------------------ 
class ProtectedClass:protected Base//保护继承 
{ 
    public: 
        void test() 
        { 
            a1 = 1;//a1在这里被转变为protected 
            a2 = 2;//a2在这里被转变为protected 
            a3=3;//错误，派生类不能访问基类的私有成员 
        } 
};
class privateClass:private Base//保护继承 
{ 
    public: 
        void test() 
        { 
            a1 = 1;//a1在这里被转变为private
            a2 = 2;//a2在这里被转变为private 
            a3=3;//错误，派生类不能访问基类的私有成员 
        } 
};
派生类不能访问基类的私有成员
公有继承是把基类的保护的成员和公有成员继承，不能继承私有成员；
保护继承是把基类的保护的成员和公有成员变为保护成员，不能继承私有成员；
私有继承是把基类的保护的成员和公有成员变为私有成员，不能继承私有成员；

多重继承

class A:public B,protected C

{
}

继承

class A:public B

{

ptotected:

double r;

public:

A(int x=0;int y=1;int double rr=3):B(x,y)

{r=rr;}

3继承

class A

{private:

int x;

public:

A(int i)

{x=i;}

~A(){};

}

class B:

{private :

int y;

A h;

public:

B(int yy;int i):A(i)

{ yy=y;}

}

虚基类关键字virtual,保存一份共同基类副本

class A

{}

class B:virtual public A

{}

class C:virtual public A

{}

class D:public B,public C

{}

3动态联编

虚函数是C++中用于实现多态(polymorphism)的机制,引用继承他的函数

class A
{
public:
virtual void foo() { cout << "A::foo() is called" << endl;}
};

class B: public A
{
public:
virtual void foo() { cout << "B::foo() is called" << endl;}
};

　　那么，在使用的时候，我们可以：

A * a = new B();
a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!

静态联编是在程序编译时系统就能决定调用哪个函数，如函数重载就是静态编译称早期联编。

虚折构函数，在基类中放指针申请内存空间；

 

如下声明表示一个函数为纯虚函数：

class A
{
public:
virtual void foo()=0; // =0标志一个虚函数为纯虚函数
};

　　一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。

2.3 虚析构函数
　　析构函数也可以是虚的，甚至是纯虚的。例如：

class A
{
public:
virtual ~A()=0; // 纯虚析构函数
};

抽象类是有一个或多个纯虚析构函数，没有纯虚析构函数事具体类；