C/C++开发需要特殊注意的小知识

__FUNCTION__,__LINE__,__FILE__

用于日志定位，分别代表函数名、行号、文件名

#include <stdio.h>
#include <stdlib.h>
void test()
{
	printf("cur file : (%s) ; cur func : (%s) ; cur line : (%d)\n", __FILE__, __FUNCTION__, __LINE__);
}

int main(int argc, char** argv)
{
	test();
	return 0;
}

文件换行符

不同操作系统下的文件换行符不同，Linux下换行符是\n，Windows下是\r\n

变量初始化

1、直接初始化：使用()，如int iVal(10);
2、复制初始化：使用=，如int iVal = 10;

自增（++）自减（–）

1、前置（++i）返回增加后的i值，返回的是对象本身，是左值，可以继续赋值
2、后置（i++）返回增加前的i值，是右值，不可以继续赋值
3、无论前置还是后置最后i都自增1

    int i = 0;
    ++i = 10;   //正确
    //i++ = 10; //编译错误，提示需要左值

关于左值与右值的补充说明
（1）左值（lvalue）：是内存里可以访问的地址，可以出现在赋值语句的左边或右边
（2）右值（rvalue）：表示一个数据，只能出现在赋值语句的右边

switch-case

1、如果匹配的case语句执行完没有break，则会越过后面的case判断，继续执行后面的其他语句，直到switch结束或遇到break语句位置
2、case标号必须是整型常量表达式

    int i = 0;
    switch (i)
    {
    case 0:
        cout << i << endl;
    case 1:
        cout << i << endl;   //由于case 0执行后没有break会继续执行，输出0
    }

以上case等价于

    case 0:
    case 1:
        cout << i << endl;
        cout << i << endl; 

类class与结构体struct区别

只是访问级别不同
1、类：定义在第一个访问标号（public/protected/private）前的任何成员都隐式指定为private
2、结构体：任何成员默认都是public

字符数组初始化

char chArray[] = "C++"; //数组末尾会自动补\0，因此维度为4

如果写成char chArray[3] = “C++”;编译时会提示数组越界

指针

• 指针与引用
  1、定义引用必须初始化，而指针定义时不需要一定初始化
  2、给引用赋值修改的是引用所关联的对象的值，而指针赋值操作仅修改指针的值
• 指针和const
  1、const 指针：int * const pValue = &nVal;//pValue不可以改变，但是*pValue可以改变
  2、指向const对象的指针：const int *pValue= &nVal; //pValue可以改变，但是*pValue不可以改变
  3、指向const对象的const指针：const int * const pValue= &nVal; //pValue和*pValue都不可以改变
• 指针和typedef

typedef int* pint;
const pint pValue ;

const修饰的是pint的类型，是指针类型，所以是const指针，对应int *const pValue ;

函数

• 函数参数
  引用形参可以避免参数复制，尤其是避免大型对象如字符串、数组、类的复制
• 内联函数（inline）
  1、在编译时会将内联函数展开，避免函数调用的开销
  2、inline必须与函数定义体（cpp）放在一起。
  3、在成员函数的定义体放在类的声明中（头文件）则成员函数将自动地成为内联函数。
  4、每一处内涵函数的调用都要复制代码，所以内联函数的代码要小。
• 类成员函数
  1、每个成员函数都有一个额外的、隐含的形参this。在调用成员函数时，形参this初始化为调用函数的对象的地址。this的类型是一个指向类类型的const指针，可以改变this所指向的成员变量的值，但不能改变this保存的地址
  2、const成员函数，改变隐含的this形参的类型为指向const对象的const指针，所以不能改变this保存的地址，而且不能改变this所指向的成员变量的值。
• 指向函数的指针
  方法一：int (*pf)(int i,int j);
  方法二：typedef int (*pf)(int i,int j);

int (*pf)(int i, int j);
int Add(int i, int j)
{
    return i + j;
}

void TestFunc()
{
    pf = Add;
    std::cout << pf(10, 15) << endl;
}

类

• 构造函数分两个阶段执行
  1、初始化阶段，对应构造函数初始化列表
  2、计算阶段，对应构造函数的函数体
  A::A():a(5),b(5) //初始化
  { c = 5} //计算
• 构造函数初始化
  1、如果类的成员变量为const对象或引用类型的对象，则不能对它们赋值，必须在构造函数的初始化列表中执行
  2、构造函数初始化列表仅指定用于初始化成员的值，并不指定这些初始化执行的次序。成员被初始化的次序就是定义成员的次序。如果一个成员是根据其他成员而初始化，则成员初始化的次序是至关重要的。
  3、如果类存在继承关系，派生类必须在其初始化列表里调用基类的构造函数（在基类没有默认构造函数的前提下）
• 默认构造函数
  只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。如果定义了其他构造函数，则提供一个默认构造函数总是对的。
• 隐式类类型转换

    class A
    {
    public:
        A(int i) { m_nVal = i; }
    public:
        int m_nVal;
    };//注意此处的分号
    A a = 10; //隐式转换，通过使用构造函数从10生成一个新的临时A对象，新的对象再赋值给a

通过将构造函数声明为explicit，来防止隐式转换

    class A
    {
    public:
        explicit A(int i) { m_nVal = i; }
    public:
        int m_nVal;
    };
    //A a = 10;  //失败
    A a(10);

• static成员函数
  1、类外部定义static成员时，无需重复指定static保留字，该保留字只出现在类定义体内部的声明处
  2、static成员是类的组成部分但不是任何对象的组成部分，所以static成员函数没有this指针

class A
{
public:
    explicit A(int i) { m_nVal = i; }
    static void printStaticVal();
public:
    int m_nVal;
    static int m_nStaticVal;
   //可以初始化const static int m_nConstStaticVal = 10，但该数据成员仍必须在类定义体外定义const int A::m_nConstStaticVal；
    const static int m_nConstStaticVal; 
};
int A::m_nStaticVal = 10; //不能加static修饰，并且必须在类定义体外定义，不能通过类的构造函数初始化
const int A::m_nConstStaticVal = 10;

void A::printStaticVal()    //不能加static修饰
{
    std::cout << m_nStaticVal << endl;
}
class B
{
public:
    explicit B(int i) { m_nVal = i; }
public:
    int m_nVal;
};
    std::cout << "A内存大小："<< sizeof(A) << endl;
    std::cout << "B内存大小：" << sizeof(B) << endl; //A与B内存大小相同，都为4字节
    A a(10);
    a.printStaticVal();
    A::printStaticVal();

复制控制

复制构造函数、赋值操作符和析构函数总称为复制控制

• 复制构造函数
  是一种特殊构造函数，具有单个形参，该参数常用const修饰，是对该类类型的引用。
• 复制构造函数调用时机
  1、当定义一个新对象并用一个同类型的对象对它进行初始化时，将显式使用复制构造函数
  2、当将该类型的对象传递给函数或从函数返回该类型的对象时，将隐式使用复制构造函数
• 复制构造函数禁止复制
  1、将复制构造函数声明为private
  2、如果禁止类的友元或者成员进行复制，则只声明private复制构造函数但不对其定义
• 复制构造函数和赋值函数
  复制构造函数是在对象创建时调用的，而赋值函数只能被已经存在了的对象调用。

class C
{
public:
    explicit C(int i) { m_nVal = i; }
    C(const C& c) { m_nVal = c.m_nVal; } //复制构造函数
    C& operator=(const C& c) { m_nVal = c.m_nVal; } //赋值函数
public:
    int m_nVal;
};
C c1;
C c2;
C c3 = c1; //调用复制构造函数
c2 = c1; //调用赋值函数

• 析构函数
  1、如果类需要析构函数，则它也需要赋值操作符和复制构造函数
  2、即使我们编写了自己的析构函数，合成析构函数依然运行

面向对象编程

面向对象编程基于三个基本概念：数据抽象（用类进行数据抽象）、继承和动态绑定

• 动态绑定
  通过基类的引用或指针调用虚函数时发生动态绑定。用引用或指针调用虚函数在运行时确定，被调用的函数是引用或指针所指对象的实际类型所定义的。如果调用非虚函数，则无论实际对象是什么类型，都执行基类类型所定义的函数。
• public、private、protected访问标号
  1、private成员只能由基类的成员和友元访问，派生类不能访问private成员
  2、protected成员不能被类对象访问，但是可以被该类的派生类访问
  3、派生类只能通过派生类对象访问其基类的protected成员，不能访问基类类型对象的protected成员
  void Derive::memfcn(const Derive& d,const Base& b) //可以访问d的protected成员，不能访问b的protected成员
• 虚函数
  一旦函数在基类中声明为虚函数，它就一直为虚函数，派生类无法改变该函数为虚函数的事实。派生类重定义虚函数时，可以使用virtual保留字，但不是必须这样做。
• 派生类析构函数
  对象撤销顺序与构造顺序相反：首先运行派生类的析构函数，然后按继承层次依次向上调用各基类析构函数

函数隐藏、重载、覆盖

• 重载
  函数重载的特征
  1、相同的范围（同一个类中）
  2、函数名字相同
  3、参数不同
  4、virtual关键字可有可无。
  5、不关心函数返回值类型
• 覆盖
  是指派生类中存在重新定义基类的函数，其函数名、参数列、返回值类型必须同父类中相应被覆盖的函数严格一致，覆盖函数和被覆盖函数只有函数体不同，当基类指针指向派生类对象，调用该同名函数时会自动调用子类中的覆盖版本，而不是父类中的被覆盖函数版本。
  覆盖的特征
  1、不同的范围（分别位于派生类和基类）
  2、函数名字相同
  3、参数相同
  4、返回值类型相同
  5、基类函数必须有virtual关键字。
• 隐藏
  隐藏的特征
  1、不同的范围（分别位于派生类和基类）
  2、函数名字相同
  3、参数可以不同
  4、返回值类型可以不同
• 隐藏与覆盖调用注意事项
  1、被隐藏的函数，在子类被强制转换成父类后，访问的是父类中的函数
  2、被覆盖的函数，在子类被强制转换成父类后，调用的还是子类自身的函数