自己再捋一捋C/C++

---

甜点

1. 理解 C++ 中的头文件和源文件的作用。（面试被问过能不能 include .cpp文件）
2. extern 与头文件(*.h)的区别和联系。
3. C++ 中的 inline 用法。

指针

1. 指针是变量，这个变量存放的是一个地址，对于32位系统来说，这个地址有32bit也就是4个byte,而对于32位操作系统来说，这个地址就有64bit，也就是８byte。可以利用sizeof()运算符来返回分配给指针变量的空间大小（多少个字节）。(参考网页：sizeof和strlen区别。)

char *p = "123";
std::cout<<sizeof(p)<<std::endl; //32位操作系统输出位4，64位系统输出为８

2. 关于NULL指针，首先它是一个指针，它所存的地址为全0。在指针变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。(参考网页：C++ Null 指针。)

3. 指针和数组的区别：指针和数组在大多数时候是可以互换的，但是需要注意的是，数组名不能自增(参考网页：C++ 指针 vs 数组。)，如：

int i[3]={0};
std::cout<<*(i++)<<std::endl; 
//i++错误，修改 i 的值是非法的。
//这是因为 i 是一个指向数组开头的常量，不能作为左值。

---

引用

1. 引用变量是一个变量的别名，也就是说，它是某个已存在变量的另一个名字（eg: int a=0中a的别名）。一旦把引用（b）初始化为某个变量（a），就可以使用该引用名称（b）或变量名称（a）来指向变量（a）的值。（参考：C++ 引用）

#include <iostream>
using namespace std;
 
int main ()
{
   // 声明简单的变量
   int    i;
   double d;
 
   // 声明引用变量
   int&    r = i;
   double& s = d;
   
   i = 5;
   cout << "Value of i : " << i << endl;	//输出为5
   cout << "Value of i reference : " << r  << endl; //输出为5
 
   d = 11.7;
   cout << "Value of d : " << d << endl;	//输出为11.7
   cout << "Value of d reference : " << s  << endl; //输出为11.7
   
   return 0;
}

2. 引用和指针的区别：
   (1) 不存在空引用。引用必须连接到一块合法的内存。
   (2) 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
   (3) 引用必须在创建时被初始化。指针可以在任何时间被初始化。

3. C++之所以增加引用类型， 主要是把它作为函数参数，以扩充函数传递数据的功能（参考C++ 把引用作为参数）。C++ 函数传参：
   (1) 将变量名作为实参和形参。这时传给形参的是变量的值，传递是单向的。如果在执行函数期间形参的值发生变化，并不传回给实参。因为在调用函数时，形参和实参不是同一个存储单元。// 同 c
   (2) 传递变量的指针。形参是指针变量，实参是一个变量的地址，调用函数时，形参(指针变量)指向实参变量单元。这种通过形参指针可以改变实参的值。// 同 c
   (3) C++提供了 传递变量的引用。形参是引用变量，和实参是一个变量，调用函数时，形参(引用变量)指向实参变量单元。这种通过形参引用可以改变实参的值。

4. 引用作为函数返回值：通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似。当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。
   当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。（参考C++ 把引用作为返回值）

#include <iostream>
using namespace std;
double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};
double& setValues( int i )
{
  return vals[i];   // 返回第 i 个元素的引用
}
 
// 要调用上面定义函数的主函数
int main ()
{
 
   cout << "改变前的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
 
   setValues(1) = 20.23; // 改变第 2 个元素
   setValues(3) = 70.8;  // 改变第 4 个元素
 
   cout << "改变后的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
   return 0;
}

输出结果为：

改变前的值
vals[0] = 10.1
vals[1] = 12.6
vals[2] = 33.1
vals[3] = 24.1
vals[4] = 50
改变后的值
vals[0] = 10.1
vals[1] = 20.23
vals[2] = 33.1
vals[3] = 70.8
vals[4] = 50

int& func() {
   int q;
   //! return q; // 在编译时发生错误,局部变量不可返回
   static int x;
   return x;     // 安全，x 在函数作用域外依然是有效的
}

---

友元

1. 类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。（参考C++ 友元函数）
   因为友元函数没有this指针，则参数要有三种情况：
   （1）要访问非static成员时，需要对象做参数；
   （2）要访问static成员或全局变量时，则不需要对象做参数；
   （3）如果做参数的对象是全局对象，则不需要对象做参数.
   可以直接调用友元函数，不需要通过对象或指针.

---

继承

1. 面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。
   当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。（参考C++ 继承）
   处理参考链接中描述的一般操作外，还有其网页下方的笔记部分的多继承（环状继承）的虚拟继承格式。探讨程序：

#include <iostream>
using namespace std;
//基类
class D
{
public:
    D(){cout<<"D()"<<endl;}
    ~D(){cout<<"~D()"<<endl;}
protected:
    int d;
};

class B:virtual public D
{
public:
    B(){cout<<"B()"<<endl;}
    ~B(){cout<<"~B()"<<endl;}
protected:
    int b;
};

class A:virtual public D
{
public:
    A(){cout<<"A()"<<endl;}
    ~A(){cout<<"~A()"<<endl;}
protected:
    int a;
};

class C:public B, public A
{
public:
    C(){cout<<"C()"<<endl;}
    ~C(){cout<<"~C()"<<endl;}
protected:
    int c;
};

int main()
{
    cout << "Hello World!" << endl;
    C c;  //类可以分别换成D, B, A 试试。同时撤去virtual再行观察sizeof()输出值　
    cout<<sizeof(c)<<endl;
    return 0;
}

2. 继承中，比较难理解的一个point有构造函数的继承关系：(参考C++11 中的继承构造函数，C++中虚继承派生类构造函数的正确写法)
   （１） 如果子类没有定义构造方法，则调用父类的无参数的构造方法。
   （２） 如果子类定义了构造方法，不论是无参数还是带参数，在创建子类的对象的时候,首先执行父类无参数的构造方法，然后执行自己的构造方法。
   （３） 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数，则会调用父类的默认无参构造函数。
   （４） 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数且父类自己提供了无参构造函数，则会调用父类自己的无参构造函数。
   （５） 在创建子类对象时候，如果子类的构造函数没有显示调用父类的构造函数且父类只定义了自己的有参构造函数，则会出错（如果父类只有有参数的构造方法，则子类必须显示调用此带参构造方法）。
   再来看一看我摸了老半天的程序：

#include <iostream>
#include <stdio.h>
using namespace std;
//基类
class Shape 
{
	protected:
		int width, height;
	public:
	Shape( int a, int b=3)
	{
	   width = a;
	   height = b;
	   cout<<"Shape..."<<endl;
	}
	virtual int add()
	{
		return width+height;
	}
};

class Rect:public Shape
{
	public:
	Rect(int a,int b=2):Shape(a)
	{
		cout<<"Rect..."<<endl;
	}
	int add()
	{
		return width+2*height;
	}
};

int main()
{
	Rect rect(1);
	cout<<rect.add()<<endl;
	return 0;
}

程序输出为

Shape...
Rect...
7

虚函数暂时在这不解释，程序里边调用的是派生类Rect的add()函数。主要理解
Rect(int a,int b=2):Shape(a)
很明显，rect.width=1,rect.height=3。理解的重点在

Rect(int a,int b=2):Shape(a)

语句 Rect rect(1); 直接调用类 Rect 的构造函数 Rect(int a,int b=2)，从而有a=1,b=2 然后 Rect 的构造函数就将 a=1 传给了后面的 Shape(a)，这样就调用了基类 Shape 的构造函数且传入参数仅为 a=1（参数 b=2 并未传入），而 Shape 的构造函数默认 b=3，这样下来 rect.width=1,rect.height=3，就很好理解了。

3. 虚函数是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。
   您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。（参考C++ 多态）

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      //pure virtual function 纯虚函数
      virtual int area() = 0;
};

此外还有如下大佬笔记：（摘自C++ 数据封装）
C++中, 虚函数可以为private, 并且可以被子类覆盖（因为虚函数表的传递），但子类不能调用父类的private虚函数。虚函数的重载性和它声明的权限无关。
一个成员函数被定义为private属性，标志着其只能被当前类的其他成员函数(或友元函数)所访问。而virtual修饰符则强调父类的成员函数可以在子类中被重写，因为重写之时并没有与父类发生任何的调用关系，故而重写是被允许的。
编译器不检查虚函数的各类属性。被virtual修饰的成员函数，不论他们是private、protect或是public的，都会被统一的放置到虚函数表中。对父类进行派生时，子类会继承到拥有相同偏移地址的虚函数表（相同偏移地址指，各虚函数相对于VPTR指针的偏移），则子类就会被允许对这些虚函数进行重载。且重载时可以给重载函数定义新的属性，例如public，其只标志着该重载函数在该子类中的访问属性为public，和父类的private属性没有任何关系！
纯虚函数可以设计成私有的，不过这样不允许在本类之外的非友元函数中直接调用它，子类中只有覆盖这种纯虚函数的义务，却没有调用它的权利。

---

时间

1. 引用头文件：ctime（参考C++ 日期 & 时间）

   unsigned long sec;
   sec = time(NULL);
   // 输出实际值
   cout << "Number of seconds :" << sec << endl;