测量程序设计

---

title: C++知识预备
date: 2020-02-26 16:58:09
categories: 测量程序设计

标准输出流（cout）
cout 对象"连接"到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的，如下所示：

int main( )
{
   char str[] = "Hello C++";
 
   cout << "Value of str is : " << str << endl;
}

流插入运算符 << 在一个语句中可以多次使用。

标准输入流（cin)
cin 对象附属到标准输入设备，通常是键盘。cin 是与流提取运算符 >> 结合使用的，如下所示：

int main( )
{
   char name[50];
 
   cout << "请输入您的名称： ";
   cin >> name;
   cout << "您的名称是： " << name << endl;
 
}

流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句：

cin >> name >> age;

相当于下面两个语句：

cin >> name;
cin >> age;

类与对象
类的定义以关键字 class 开头，例如：

class Box
{
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};

类的成员：public //公共成员 private //私有成员 protected //受保护的成员。

数据成员通常是私有的；成员函数通常是公有的，公有的成员函数可在类外被访问，也被称为类的外界接口。

***TIPS：***在定义类时，只是定义了一种导出的数据类型，并不为类分配存储空间，所以，在定义类中的数据成员时，不能对其初始化。

*类成员函数：*把定义和原型写在类定义内部的函数，类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。

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

也可以在类的外部使用范围解析运算符 :: 定义该函数，如下所示：

double Box::getVolume(void)
{
    return length * breadth * height;
}

类对象初始化——构造函数：

实例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VEv5D7qI-1609917406870)(1.png)]

继承
继承允许我们依据另一个类来定义一个类，当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。
这个已有的类称为基类，新建的类称为派生类。
定义一个派生类，形式如下：``class derived-class: access-specifier base-class`
实例：

#include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   return 0;
}

访问权限：

访问	public	protect	private
同一个类	yes	yes	yes
派生类	yes	yes	no
外部的类	yes	no	no

继承类型：
几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：
公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

多继承：
从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

重载函数
重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。
当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。
函数重载实例：

#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};

指针

什么是指针？
指针是一个变量，其值为另一个变量的地址。
像其他变量或常量一样，必须在使用指针存储其他变量地址之前，对其进行声明。
指针变量声明的一般形式为：
type *var-name;
如：

int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;    /* 一个字符型的指针 */

所有类型指针的实际数据都是一样的，是一个代表内存地址的长的十六进制数，如0xbfebd5c0。
不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

指针基本操作实例：

#include <iostream>
 
using namespace std;
 
int main ()
{
   int  var = 20;   // 实际变量的声明
   int  *ip;        // 指针变量的声明
 
   ip = &var;       // 在指针变量中存储 var 的地址
 
   cout << "Value of var variable: ";
   cout << var << endl;
 
   // 输出在指针变量中存储的地址
   cout << "Address stored in ip variable: ";
   cout << ip << endl;
 
   // 访问指针中地址的值
   cout << "Value of *ip variable: ";
   cout << *ip << endl;
 
   return 0;
}

指针详解
1、Null指针：内存地址为0，按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

2、指针的四种算数运算：++ -- + -,假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，
让我们对该指针执行下列的算术运算：ptr++
在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 个字节。
递增一个指针：
我们喜欢在程序中使用指针代替数组，因为变量指针可以递增，而数组不能递增，因为数组是一个常量指针。
下面的程序递增变量指针，以便顺序访问数组中的每一个元素：

#include <iostream>
 
using namespace std;
const int MAX = 3;
 
int main ()
{
   int  var[MAX] = {10, 100, 200};
   int  *ptr;
 
   // 指针中的数组地址
   ptr = var;
   for (int i = 0; i < MAX; i++)
   {
      cout << "Address of var[" << i << "] = ";
      cout << ptr << endl;
 
      cout << "Value of var[" << i << "] = ";
      cout << *ptr << endl;
 
      // 移动到下一个位置
      ptr++;
   }
   return 0;
}

递减一个指针:ptr = &var[MAX-1];
指针的比较：while(ptr <= &var[MAX - 1])

3、指针数组：数组内存储指向int或char或其它数据类型的指针。
指针数组的声明:int *ptr[MAX] //可以看成 （int*） ptr[MAX],ptr为数组，由MAX个整数指针组成
实例：将3个整数存储在一个指针数组中

#include <iostream>
 
using namespace std;
const int MAX = 3;
 
int main ()
{
   int  var[MAX] = {10, 100, 200};
   int *ptr[MAX];
 
   for (int i = 0; i < MAX; i++)
   {
      ptr[i] = &var[i]; // 赋值为 整数的地址
   }
   for (int i = 0; i < MAX; i++)
   {
      cout << "Value of var[" << i << "] = ";
      cout << *ptr[i] << endl;
   }
   return 0;
}

4、什么是指向指针的指针？

首先，它是一个指针变量。

其次，它包含了另一个指针变量的地址，该指针变量指向实际值位置。

PPtr ——> Ptr ——> Var

(Address)——>(Address)——>(Value)

声明一个指向指针的指针变量：int **var;

范例：

#include <iostream>
 
using namespace std;
 
int main ()
{
    int  var;
    int  *ptr;
    int  **pptr;
 
    var = 3000;
 
    // 获取 var 的地址
    ptr = &var;
 
    // 使用运算符 & 获取 ptr 的地址
    pptr = &ptr;
 
    // 使用 pptr 获取值
    cout << "var 值为 :" << var << endl;
    cout << "*ptr 值为:" << *ptr << endl;
    cout << "**pptr 值为:" << **pptr << endl;
 
    return 0;
}

5、传递指针给函数：声明函数参数为指针类型即可。能接受指针作为参数的函数，也能接受数组作为参数。

6、从函数返回指针：为了做到这点，必须声明一个返回指针的函数，如下所示：

int * myFunction()
{
.
.
}

另外，C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。

面向对象编程

将数据和处理数据的函数封装到一个类（class）中，而以类作为数据类型定义的 “变量” 称为 “对象”（object）。

在一个对象里面，只有属于该对象的函数才可以存取该对象的私有数据，而其它函数不能对它进行操作。

类的构造函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。