C++语言特性备忘

main函数

控制台程序
int main() {
    return 0;
}

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

windows程序
int APIENTRY _tWinMain(HINSTANCE hInstance,
                       HINSTANCE hPrevInstance,
                       LPTSTR    lpCmdLine,
                       int       nCmdShow) {
    return 0;
}

基本数据类型

类型	含义	位数
bool	布尔型	-
char	字符型	8位
short	短整型	16位
int	整型	32位
long	长整型	32位
float	单精度浮点型	6位有效数字
double	双精度浮点型	10位有效数字

char、short、int、long均可加signed、signed修饰，表示有无符号，无符号值域大于0，正数范围比有符号大一倍。

带类型常量表示：
20 十进制
024 八进制
0x14 十六进制
0.5f 单精度浮点
默认的浮点常量位double型

运算符

-算数运算符

加号（+），减号（-），乘号（*），除号（/），取模（%）

-赋值运算符

=

-自动递增递减

递增（++），递减（–）

-关系运算符

大于（>），小于（<），大于等于（>=），小于等于（<=），等于（==），不等于（!=）。等于和不等于适用于所有内建的数据类型，但其他比较不适用于boolean 类型

-逻辑运算符

AND（&&），OR（||）,NOT（！）,只可将AND，OR 或NOT 应用于布尔值。”短路”，一旦逻辑运算表达式的值已经求出，后续表达式不计算值。

-按位运算符

若两个输入位都是1，则按位AND运算符（&）在输出位里生成一个1；否则生成0。
若两个输入位里至少有一个是1，则按位OR 运算符（|）在输出位里生成一个1；只有在两个输入位都是0的情况下，它才会生成一个0。
若两个输入位的某一个是1，但不全都是1，那么按位XOR（^，异或）在输出位里生成一个1。
按位NOT（~，也叫作“非”运算符）属于一元运算符；它只对一个自变量进行操作（其他所有运算符都是二元运算符）。按位NOT生成与输入位的相反的值——若输入0，则输出1；输入1，则输出0。
按位运算符可与等号（=）联合使用，以便合并运算及赋值：&=，|=和^=都是合法的（由于~是一元运算符，所以不可与=联合使用）。

-移位运算符

移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型（主类型的一种）。
左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。
右移位运算符（>>）高位依据数据正负决定补0还是1

-三元if-else运算符

布尔表达式 ? 值0:值1

-逗号运算符

逗号不仅作为函数自变量列表的分隔符使用，也作为进行后续计算的一个运算符使用。

-箭头操作符

->
类成员函数或者变量使用

-sizeof

求取类型占用位数

控制流

-i f- e l s e

int result = 0;
if(testval > target)
    result = -1;
else if(testval < target)
    result = +1;
else
    result = 0; // match
return result;

-while

while(布尔表达式)
语句

-do while

do
语句
while(布尔表达式)

-for

for( char c = 0; c < 128; c++) {
    if (c != 26 ) // ANSI Clear screen
    System.out.println("value: " + (int)c +" character: " + c);
}

-break,continue

break 用于强行退出循环，不执行循环中剩余的语句。而continue 则停止执行当前的反复，然后退回循环起始和，开始新的反复。

-switch

switch(选择因子) {
case 整数值1 : 语句; break;
case 整数值2 : 语句; break;
case 整数值3 : 语句; break;
case 整数值4 : 语句; break;
case 整数值5 : 语句; break;
//..
default:语句;
}

数组

 int b[2][3]={{0,0,0},{0,0,0}};  // 定义一个二维整型数组
 也可以[]空着，由初始化值自动决定维数
 数组访问下表区间0-length-1

指针

int a = 10;
int *p = NULL;
int *p1 = &a;

int *p[]; 指针数组
int (*p)[]; 指向数组的指针

引用

int &i = a;  i引用a
引用变量与被引用变量是同一地址

int *&p;  指针引用

枚举

enum Cities {
    Guangzhou = 4, 
    Shenzhen = 4, 
    Hongkong = 4, 
    Shanghai = 2, 
    Beijing = 3, 
    Chongqi = 5
};

const

const int i = 10; // 常量

const int *p;
int const *p;
以上两种等同，可以修改指向的对象，但不能修改指向对象的值；

int * const p;
这种不能修改指向的对象，但能修改指向的对象的值。

const修饰函数
int set(const int i) {
    ++i; // error，const修饰，无法修改
}
一般不如上使用，毕竟值传递，本身不会影响实参的值，对指针以及引用类型修饰会比较有用
const int* getPoint() {
        ....
}
修饰返回值，表示该指针指向对象的值不能修改
class A {
    void func() const {
    }   //常成员函数, 它不改变对象的成员变量. 也不能调用类中任何非const成员函数。
}

static

修饰类成员函数或者成员变量的话，表示成员函数或者变量为类所有，静态的
修饰类外的全局变量的话，表示该变量作用域位该文件，无法被extern
静态局部变量，函数中static修饰的局部变量，这种变量一旦被初始化后就一直存在，只会初始化一次，随着函数的调用

typedef

重命名

typedef int Integer;
typedef enum {
    shanghai = 0,
    guangdong
} Cities;               //枚举重命名
typedef int (*func)(int a, char b);  //函数指针重命名

函数

int add(int a, int b) {
    return a + b;
}

函数参数传递方式：
值传递、指针传递、引用传递
值传递类型在函数区域内修改值并不能影响函数之外的实参

函数指针

typedef int (*func)(int a, char b);  //普通函数指针 
typedef int（Object::*func）(int a);  //类函数的函数指针

调用
func（a,b）;
(*fuc)(a,b);  //普通调用
(c->*fuc)(a); //类函数指针的调用

宏定义

头文件宏，防止多次包含
#ifndef _CLASS_A_DEFINE_H_
#define _CLASS_A_DEFINE_H_

class A {
};

#endif

#define SAFE_DELETE(p)   do { if(p) { delete (p); (p) = 0; } } while(0)

头文件

‘#include <> 从系统库目录搜索起，一般用于系统库头文件引用
‘#include “”从当前工程目录搜索起，一般用于项目头文件

名字空间

为了防止命名冲突，采用名字空间来避免；
源代码处使用
namespace XXX {
………
}
引用某个名字空间
using namespace XXX;

类

类定义，继承

A.h

class A {
public:
    A();
    virtual ~A();
private:
    int a,b,c;
}

*********************
A.cpp

A::A() 
    :a(0)
    ,b(1)
    ,c(2)
{
}

A::~A() {
}

**********************
B.h

public class B : public A {
public:
    B();
    virtual ~B();

private:
    int e,f,g;
}

************************
B.cpp

B::B()
: A() 
, e(0)
, f(0)
, g(0)
{
}

B::~B() {
}

拷贝构造

class A {
public:
    A();
    A(const A& a);   //拷贝构造函数
}

如果我们没有定义拷贝构造函数，编译器会默认生成一个，默认的拷贝构造是浅拷贝，就是值传递，指针类成员变量引用的地址相同，所以改动一个对象会影响拷贝后的对象，可以自己实现深度拷贝。

private、protected、public
private私有成员，protected是继承的类可以访问，public公有成员

友元

 class A {
     friend class B;  // 友元，类
     friend void C::func(); //友元，函数
 }

类文件构成
一般由头文件（.h）和实现文件(.cpp)构成，头文件中定义，实现文件实现相关函数

虚函数

class A {
    virtual void func(); // 虚函数
}

class B {
    virtual void func(); // 虚函数
}

class C {
    virtual void func() = 0; // 纯虚函数
}

其他

• 声明外部变量

  extern int a;

• 类型声明

  class A; 一般用于头文件中，防止头文件引用过长，导致编译速度非常慢。

• 类型转换

  类型自动转换，内置类型间会自动转换
  float f = 10.5;
  int i = f; // 自动将浮点数舍去小数转换成整数

  dynamic_cast: 通常在基类和派生类之间转换时使用，转换不成功会返回null
  const_cast: 主要针对const和volatile的转换，去掉或者增加常量属性
  static_cast: 内置的数据类型间互相转换，对于类只能在有联系的指针类型间进行转换，不具备继承关系的类之间无法使用
  reinterpret_cast: 用于进行没有任何关联之间的转换，直接会根据二进制数据转换类型，一般不用

• extern “C”

c++与c编译器编译函数后的命名方式不太一致，用extern “C”方式让编译器强制按c方式编译和寻找函数，达到c++调用c语言实现的函数的目的。

• new delete
  

  c++分配内存方法

其他扩展内容

• 不定参函数
• 异常处理
• 运算符重载
• 模板