类与对象概念

定义一个数据类型 没有任何数据,定义了类的对象包括了什么
例子:

#include<iostream>
using name space std;
class Box
{
public: //定义了访问属性 别忘了:
double a;//定义盒子属性
double b;//同上
double c;//同上

};//别忘了有个;

我们将这个称之为一类

对象

类的实例化是对象,如果类指代一类车,那么对象就是你的一台车 定义对象的方法
类名 定义名
比如例子中 我这样Box Box1 ; 代表我的盒子是这个Box1 Box1拥有上述数据成员的属性 a,b,c 比如我们这里面举例一个长宽高

访问数据成员

访问方法 Box1.a=xxx Box1.b=xxx Box1.c=xxx,可以通过这种方式给他赋值

类成员函数

数据成员不仅可以是变量,而且可以是函数

class Box
{
   public:
      double length;         // 长度
      double breadth;        // 宽度
      double height;         // 高度
      double getVolume(void);// 返回体积
};

如上面这个例子,我可以直接在类里面就使用这个函数,例如

class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
   
      double getVolume(void)
      {
         return length * breadth * height;
      }
};

如果我们要在类外使用函数 需要用:: 例如

double Box::getVolume(void)
{

return length * breadth * height;

}

但要记住,函数声明是必不可少的**

类访问修饰符

如下三种 public private protect
他们的意思分别是公有成员 私有成员 受保护成员
公有成员在类外部是可以访问的
例子

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      double length;
      void setLength( double len );
      double getLength( void );
};
int main( )
{
   Line line;
   line.length=6.0;
cout <<line.length<<endl;
}

这里面我们的length是public的,所以可以直接访问并赋值,而private是不可以的

  #include <iostream>
     
    using namespace std;
     
    class Box
    {
       public:
          double length;
          void setWidth( double wid );
          double getWidth( void );
     
       private:
          double width;
    };
下面这里如果我用一个对象 Box Box1;
 Box1.width=xxx;就是绝对不行的
    第三个保护成员protected,它的派生类能进行访问,而自己不能 如下代码所示

#include <iostream>
using namespace std;
 
class Box
{
   protected:
      double width;
};
 
class SmallBox:Box // SmallBox 是派生类
{
   public:
      void setSmallWidth( double wid );
      double getSmallWidth( void );
};
 
// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
    return width ;
}
 
void SmallBox::setSmallWidth( double wid )
{
    width = wid;
}
 
// 程序的主函数
int main( )
{
   SmallBox box;
 
   // 使用成员函数设置宽度
   box.setSmallWidth(5.0);
   cout << "Width of box : "<< box.getSmallWidth() << endl;
 
   return 0;
}

他们的规则如下
有public, protected, private三种继承方式,它们相应地改变了基类成员的访问属性。

1.public 继承:基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:public, protected, private

2.protected 继承:基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:protected, protected, private

3.private 继承:基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:private, private, private

但无论哪种继承方式,上面两点都没有改变:

1.private 成员只能被本类成员(类内)和友元访问,不能被派生类访问;

2.protected 成员可以被派生类访问。

构造函数和析构函数

构造函数是一个和类名称相同的函数 不会返回任何类型,也不是void类型,可以用来输出一句话,用来给成员赋予初值 ,默认的构造函数是没有参数值的,但如果需要也可以有

class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line(double len);  // 这是构造函数
 
   private:
      double length;
};
 
// 成员函数定义,包括构造函数
Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
}

析构函数就是在构造函数前面加一个~,他的作用是跳出程序前释放掉资源 如上例中~Line()就是析构函数

拷贝构造函数

如果在类中没有定义拷贝构造函数,编译器会自行定义一个。如果类带有指针变量,并有动态内存分配,则它必须有一个拷贝构造函数
使用时机
(1)一个对象以值传递的方式传入函数体
(2)一个对象以值传递的方式从函数返回
(3)一个对象需要通过另外一个对象进行初始化
例子:

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      int getLength( void );
      Line( int len );             // 简单的构造函数
      Line( const Line &obj);      // 拷贝构造函数
      ~Line();                     // 析构函数
 
   private:
      int *ptr;
};
 
// 成员函数定义,包括构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}
 
Line::Line(const Line &obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}
 
Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}
int Line::getLength( void )
{
    return *ptr;
}
 
void display(Line obj)
{
   cout << "line 大小 : " << obj.getLength() <<endl;
}
 
// 程序的主函数
int main( )
{
   Line line(10);
 
   display(line);
 
   return 0;
}

友元函数和内联函数

声明方式friend
友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类,在这种情况下,整个类及其所有成员都是友元。

#include <iostream>
 
using namespace std;
 
class Box
{
   double width;
public:
   friend void printWidth( Box box );
   void setWidth( double wid );
};
 
// 成员函数定义
void Box::setWidth( double wid )
{
    width = wid;
}
 
// 请注意:printWidth() 不是任何类的成员函数
void printWidth( Box box )
{
   /* 因为 printWidth() 是 Box 的友元,它可以直接访问该类的任何成员 */
   cout << "Width of box : " << box.width <<endl;
}

内联函数 如果想把一个函数定义为内联函数,则需要在函数名前面放置关键字 inline,在调用函数之前需要对函数进行定义。如果已定义的函数多于一行,编译器会忽略 inline 限定符。
例子

#include <iostream>
 
using namespace std;

inline int Max(int x, int y)
{
   return (x > y)? x : y;
}

// 程序的主函数
int main( )
{

   cout << "Max (20,10): " << Max(20,10) << endl;
   cout << "Max (0,200): " << Max(0,200) << endl;
   cout << "Max (100,1010): " << Max(100,1010) << endl;
   return 0;
}

1.在内联函数内不允许使用循环语句和开关语句;
2.内联函数的定义必须出现在内联函数第一次调用之前;
3.类结构中所在的类说明内部定义的函数是内联函数
优点: 当函数体比较小的时候, 内联该函数可以令目标代码更加高效. 对于存取函数以及其它函数体比较短, 性能关键的函数, 鼓励使用内联.

缺点: 滥用内联将导致程序变慢. 内联可能使目标代码量或增或减, 这取决于内联函数的大小. 内联非常短小的存取函数通常会减少代码大小, 但内联一个相当大的函数将戏剧性的增加代码大小. 现代处理器由于更好的利用了指令缓存, 小巧的代码往往执行更快。