c++类的知识点(2)

前一随笔讲述了类的概念和类的基本理念(即数据封装,数据抽象.当然,不限于此,这里只概括到这里)

数据封装:

　　类实现了对对象属性和方法的封装,即把它们都写在一个类中.使得二者都有了一个作用范围,即它们都是属于本类的属性和方法,至于其他类就没有对本类属性和方法的使用权.

数据抽象:

　　编程是如何使用类对象内的属性和方法的呢?   ------接口!    通过public权限的属性和方法才能对对象进行操作和使用.   public内的东西就行时插板一样,人们可以用,但是插板内部实现如何呢? 不知道!  这样就对数据实现了抽象!   使用者只知道如何用,不知道它内部结构如何,如何运转!  这就对类对象实现了抽象.

 

下面记录类的继承:

　　面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。

　　被继承的是基类,继承的称为派生类.   

　　一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名

　　继承也有多种类型,有保留的,无保留的.   分别是public    protected    private  继承.

　　如:基类是shape

　　　　派生类 class shape1:public shape{/*------*/}

　　派生之后派生类跟基类成员有啥关系呢?

　　　　按照继承类别分为:public   protected   private 三种

　　　　　　

• 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。基类的私有成员不能直接被派生类访问
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。基类的私有成员不能直接被派生类访问

上面可以看出,凡是从基类中继承下来的私有成员都不能被派生类访问,而只能间接通过基类中继承下来的public 和protected 类型成员来访问.

这就引人思考,为何?   一种可能就是因为:类有私有成员的原因即不想让它以外的事物直接访问,派生的类也不例外啊.  而派生类就是为了继承基了,,所以取中,才有了这样的规则.

 

 

/******************************************************************埋个未知***********************************************************/

复杂继承:

　　继承的话,肯定会形成一颗继承树.   高级复杂的继承就不记录了..(没能力啊)

 

 

介绍重载(overload):

　　overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。

　　从上面百度百科介绍可以看出,它就是一个针对不同输入,运转操作此特定输入的函数的一种机制.

　　本质就是多态的一种运用.

　　具体的重载有两种:

　　　　1.函数重载

　　　　　　　　函数重载是一种特殊情况，C++允许在同一作用域中声明几个类似的同名函数，这些同名函数的形参列表（参数个数，类型，顺序）必须不同，常用来处理实现功能类　　　　似数据类型不同的问题。

　　　　 例子就不举了.

 

　　　　2.运算符重载

　　　　　　c++里面运算符也可以重载. 可以重载c++内大部分运算符.  运算符重载本质是:改变运算符的运算过程叫运算符重载。 因不同数据类型使用运算符,也就体现了多态性.

　　　　　　重载的运算符是带有特殊名称的函数，运算符重载本质上是函数调用.  函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

　　　　　　

类中成员函数重载运算符+

#include <iostream>
using namespace std;
 
class Box
{
   public:
 
      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }
 
      void setBreadth( double bre )
      {
          breadth = bre;
      }
 
      void setHeight( double hei )
      {
          height = hei;
      }
      // 重载 + 运算符，用于把两个 Box 对象相加
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;
 
   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;
 
   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;
 
   return 0;
}

注意:运算符函数里面我们发现,obj.breadth等可以使用,为啥呢?

其实之前一直是有一个知识点被不全面理解的结果.

　　即:印象中，private的数据成员只能在类的成员函数中使用，无法通过类的对象直接访问！（错误理解）

　　正确的理解是：在类的成员函数中，可以直接访问私有成员。即只要在该类的成员函数中，无论是直接访问该类的私有数据成员，还是访问某个对象（必选是该类型）的私有数据成员，均是可以的！！！

　　这样就解释的通了.

还有一点特别之处:

　　运算符重载返回的对象并不会引起构造函数的调用.

友元运算符重载函数

#include <iostream>
using namespace std;
class shape
{
   public:
      int getarea();
      shape(){}
      shape(int a,int b);             // 简单的构造函数
      shape(const shape &obj);      // 拷贝构造函数
      ~shape();                     // 析构函数
       int get(const shape &obj);
       friend shape operator+(const shape &a,const shape &b);
   private:
      int breadth,height;
};
 
int shape::getarea()
{
    return breadth*height;
}
shape::shape(int a,int b)
{
    breadth=a; height=b;
}
shape::~shape()
{
    //cout<<"jslfaskfl"<<endl;
}
shape::shape(const shape &obj)
{
    breadth=obj.breadth;
    height=obj.height;
    //cout<<"gou zao han shu bei diao yong"<<endl;
}
int shape::get(const shape &obj)
{
    return obj.height*obj.breadth;
}
shape operator+(const shape &a,const shape &b)
{
    shape obj;
    obj.breadth=a.breadth+b.breadth;
    obj.height=a.height+b.height;
    return obj;
}
int main( )
{
   shape obj1(1,1);
   shape obj2(2,2);
   shape obj3=obj1+obj2;
   //shape obj4=obj3;
   cout<<obj3.getarea()<<endl;
   return 0;
}

是不是运算符函数必须是以上两种之一呢?

未必!

#include <iostream>
using namespace std;

struct node
{
    int a,b;
};
node operator+(const node aa,const node bb)
{
    node obj;
    obj.a=aa.a+bb.a;
    obj.b=aa.b+bb.b;
    return obj;
}
int main( )
{
   node obj1;
   node obj2;
   obj1.a=1;obj1.b=2;
   obj2.a=3; obj2.b=4;
   node obj3=obj1+obj2;
   cout<<obj3.a<<" "<<obj3.b<<endl;
   return 0;
}

这里就是普通的函数,如果把struct 改成class 的话,非友元则只能访问公有数据.

 /***********************下面介绍异常处理*********************/

如果你不确定某一段代码在运行时是否会出错,那么c++的一场处理就是很好的解决方法.

try,catch,throw

三个分别对应的是:

　　存放保护代码,一旦运行错误,则自动抛出相应异常.

　　捕获异常,即异常服务子程序.

　　抛出异常.  程序主动进行的异常抛出.

try{

}catch{

}

...

针对动态内存分配:

　　

• 栈：在函数内部声明的所有变量都将占用栈内存。
• 堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。

有时候我们需要动态的内存分配,这时候就可以用new,和delete ,当然也可以用malloc 不过它只是分配额定的字节流,不会分配对象.

基本数据的分配和回收:   

　　int *p=new int;　　delete p;

一维数组:

　　int *p=new int[100];      delete  [ ] p;

二维数组的分配和回收:

　　int **p=new int *[100]; 　　

　　for(int i=0;i<100;i++)   p[i]=new int[100];

　　回收:

　　for(int i=0;i<100;i++) delete [ ] p[i];

　　delete [ ] p;

　　由此看来二维的分配和回收要麻烦点.

/***********************************************/

全局变量和局部变量的选择是这样的:
有时有两个一样的变量,全局的,局部的,有时我们想用全局的,有时我们想用局部的,到底该咋办呢?  我们默认用的是当前作用域内的变量!  如若想在局域内用全局变量可用"  ::vari_name  "

#include<iostream>
using namespace std;
int i=222;//全局 
int main()
{
    int i=111;//局部 
    cout<<"i = "<<::i<<endl;//全局打印 
    cout<<"i = "<<i<<endl;//局部打印 
    return 0;
}

 

 

/*********************命名空间*************/

命名空间像是树节点一样,可以嵌套.    即像文件系统的文件设置一样,工作原理是相同的.

命名空间可以不连续,哪里需要可以在哪里临时扩充它.

在位运算中,要知道:整型,浮点型等数据的存储的符号位是最高位,不是最低位.

比如:int 有32位二进制位.　　但是第31位(最高位)是符号位,它后面有31个数位,分别是0位,1位,...,30位.

　　如果想表示最大的那个数值,则可以使0 111111111111...111　　即2^31-1  可以写为(1<<30)-1+(1<<30) 因为直接用(1<<31)-1会发生溢出的. 　　最小值是-2^31.

编译器中的整数默认是32位四字节的.想变成八字节可以在数字后面加入"ll"字段即可.

/*****************************模板******************************/

#define N 12+45
#define N(a,b) (a*2+b*3)
#define _for(i,a,b) for(int i=a;i<=b;i++)
const char *p="0123456789"  //返回的是指针. 
//模板函数 
template<typename T>
T add(const T & a,const T &b)
{
    return a+b;
}
//模板类
template<class T>
class add
{
    public:
        T set(T a,T b);
        T area();
    private:
        T length;
        T height;
};
template<class T>
T add<T>::area()
{
    return length*height;
}
template<class T>
T add<T>::set(T a,T b)
{
    length=a; height=b;
    return a;
}