类

1. 类成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。

类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

范围解析运算符 ::

在类里面不写是什么类型，默认是 private 的。

2. 构造函数 constructor

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

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。

构造函数可用于为某些成员变量设置初始值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();  // 这是构造函数
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}

带参数的构造函数

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <iostream>
 
using namespace std;
 
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;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line(10.0);
 
   // 获取默认设置的长度
   cout << "Length of line : " << line.getLength() <<endl;
   // 再次设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

使用初始化列表来初始化字段

使用初始化列表来初始化字段：

1
2
3
4
Line::Line( double len): length(len) 
{ 
	cout << "Object is being created, length = " << len << endl; 
}

上面的语法等同于如下语法：

1
2
3
4
5
Line::Line( double len) 
{ 
	length = len; 
	cout << "Object is being created, length = " << len << endl; 
}

假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：

1
2
3
4
C::C( double a, double b, double c): X(a), Y(b), Z(c) 
{ 
	.... 
}

3. 析构函数 destructor

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

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。

析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

4. 友元函数

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。

尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

friend class ClassTwo;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#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;
}
 
// 程序的主函数
int main( )
{
   Box box;
 
   // 使用成员函数设置宽度
   box.setWidth(10.0);
   
   // 使用友元函数输出宽度
   printWidth( box );
 
   return 0;
}

输出：

Width of box : 10

5. 内联函数

C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。

对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。

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

在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。

下面是一个实例，使用内联函数来返回两个数中的最大值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#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;
}

stream

在C++中，有一个stream这个类，所有的I/O都以这个“流”类为基础的，包括我们要认识的文件I/O.

I/O 对象无拷贝或者赋值

stream 这个类有两个重要的运算符：

  1. 插入器 <<

　　向流输出数据。比如说系统有一个默认的标准输出流 cout，一般情况下就是指的显示器，所以，cout<<"Write Stdout"<<'\n' 就表示把字符串”Write Stdout”和换行字符(‘\n’)输出到标准输出流。

  1. 析取器 >>

　　从流中输入数据。比如说系统有一个默认的标准输入流(cin)，一般情况下就是指的键盘，所以，cin>>x;就表示从标准输入流中读取一个指定类型的数据。

iostream

  • istream 输入流 (cin)
  • ostream 输出流 (cout)

fstream

　　在 C++ 中，对文件的操作是通过stream的子类fstream(file stream)来实现的，所以，要用这种方式操作文件，就必须加入头文件fstream.h。
　　
　　
ofstream是从内存到硬盘，ifstream是从硬盘到内存，其实所谓的流缓冲就是内存空间

指针

基础

int* pN = &N;

pN 和 &N 是 int * 类型

*pN 是 int 类型

数组的指针

数组名实际上就是数组数据所在内存区域的首地址，表示数组在内存中的起始位置。

1
2
int nArray[3] = {1, 2, 3}; // 定义一个数组
cout << nArray;

输出为：0x7ffeeeb00ffc

可以通过把首地址赋值给指针，然后对该指针进行加减运算，使指针发生偏转指向数组中的其他元素，从而遍历整个数组。例如：

1
2
3
4
5
6
7
8
int nArray[3] = { 1, 2, 3 };   // 定义一个数组
int* pIndex = nArray;          // 将数组的起始地址赋值给指针pIndex
cout<<"指针指向的地址是："<<pIndex<<endl;       // 输出指针指向的地址
cout<<"指针所指向的数据的值是："<<*pIndex<<endl; // 输出这个位置上的数据

pIndex++;   // 对指针进行加运算，使其指向数组中的下一个值
cout<<"指针指向的地址是："<<pIndex<<endl;        // 输出指针指向的地址
cout<<"指针所指向的数据的值是："<<*pIndex<<endl;  // 输出数据

输出为 

1
2
3
4
5
6
7
指针指向的地址是：0016FA38

指针所指向的数据的值是：1

指针指向的地址是：0016FA3C

指针所指向的数据的值是：2

从输出结果中可以看到，pIndex 指针初始指向的地址是 0016FA38，也就是 nArray 这个数组的首地址。换句话说，也就是 pIndex 指向的是数组中的第一个数据，所以输出 *pIndex 的值是 1。

而在对指针进行加 1 运算后，指针指向的地址变为 0016FA3C，它向地址增大的方向偏移了 4 个字节，指向了数组中的第二个数据，输出 *pIndex的值自然也就变成了 2。

除了指针的加减算术运算之外，常用到的还有指针的关系运算。指针的关系运算通常用 == 或 != 来判断两个相同类型的指针是否相等，也就是判断它们是否指向同一地址上的同一数据，以此作为条件或循环结构中的条件判断语句。例如：

1
2
3
4
5
6
7
8
9
10
11
int nArray[3] = { 1, 2, 3 };    // 定义一个数组
int* pIndex = nArray;           // 将数组的起始地址赋值给指针pIndex
int* pEnd = nArray + 3;         // 计算数组的结束地址并赋值给pEnd
while( pIndex != pEnd )         // 在while的条件语句中判断两个指针是否相等，
                               // 也就是判断当前指针是否已经偏转到结束地址
{
    cout<<*pIndex<<endl;        // 输出当前指针指向的数据
    // 对指针进行加1 运算，
   // 使其偏移到下一个内存位置，指向数组中的下一个数据
    ++pIndex;                  
}

->

c++ 中当定义类对象是指针对象时候，就需要用到 -> 指向类中的成员；当定义一般对象时候时就需要用到 . 指向类中的成员。

例如：

1
2
3
4
5
class A
{
　　public
　　play();
}

如果定义如下：

A *p 则使用：p->play(); 左边是结构指针。

A p 则使用：p.paly(); 左边是结构变量。

总结：

箭头（->）：左边必须为指针；

点号（.）：左边必须为实体。

this 指针

在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

友元函数没有 this 指针，因为友元不是类的成员。只有成员函数才有 this 指针。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      int compare(Box box)
      {
         return this->Volume() > box.Volume();
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};
 
int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2
 
   if(Box1.compare(Box2))
   {
      cout << "Box2 is smaller than Box1" <<endl;
   }
   else
   {
      cout << "Box2 is equal to or larger than Box1" <<endl;
   }
   return 0;
}

引用

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

C++ 引用 vs 指针
引用很容易与指针混淆，它们之间有以下不同：

  • 不存在空引用。引用必须连接到一块合法的内存。
  • 一旦引用被初始化为一个对象，就不能被指向到另一个对象。
  • 指针可以在任何时候指向到另一个对象。
  • 引用必须在创建时被初始化。指针可以在任何时间被初始化。