C/C++知识点

 

 const

作用

　　1修饰变量，说明变量不可以被改变

　　2修饰指针，分为指向常量的指针和指针常量

　　3常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改

　　4修饰成员函数，说明该成员函数不能修改成员变量

使用

//类
class A
{
  private:
   const int a;
 public:
     // 构造函数
    A() { };
    A(int x) : a(x) { };        // 初始化列表

    // const可用于对重载函数的区分
    int getValue();             // 普通成员函数
    int getValue() const;       // 常成员函数，不得修改类中的 何
                                    //数据成员的值     
} ; 

void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数
    const A a;                  // 常对象，只能调用常成员函数、更新常成员变量
    const A *p = &a;            // 常指针
    const A &q = a;             // 常引用

    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量
    char* const p3 = greeting;          // 常指针，指向字符数组变量
    const char* const p4 = greeting;    // 常指针，指向字符数组常量
}

// 函数
void function1(const int Var);           // 传递过来的参数在函
//数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常指针
void function4(const int& Var);          // 引用参数在函数内
//为常量

// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：
const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：
int* const p = function7();  

static

作用

　　1 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在main函数运行前就分配了空间，如果又初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。

　　2 修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名函数重名，可以将函数定位为static

　　3 修饰成员变量，修饰曾元变量使所有的对象只保存一个变量，而且不需要生成对象就可以访问该成员。

　　4 修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在static函数内不能访问非静态成员。

this指针

　　1this指针是一个隐含于每个非静态成员函数中的特殊指针。它指向正在被该成员函数操作的那个对象。

　　2当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含使用this指针

　　3当一个成员函数被调用时，自动向他传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。

　　4this指针被隐含的声明为：className *const this, 这意味这不能给this指针赋值；在ClassName类的const成员函数中，this指针的类型为：const ClassName* const，这说明不能对this指针所指向的这种对象是不能修改的（即不能对这种对象的数据成员景象赋值操作）；

　　5　this并不是一个常规变量，而是一个右值，所以不能取得this的地址（不能&this）。

　　6 在以下场景中，经常需要显式引用this指针：

　　为实现对象的链式引用

　　为避免统一对象进行赋值操作

　　在实现一些数据结构时，如list

inline内联函数

特征

　　相当于把内联函数里面的内容卸载调用内联函数处

　　相当于不用指向进入函数 的步骤，直接执行函数体；

　　相当于宏，却比宏多了类型检查，真正具有函数特征

　　不能包含循环，递归，switch等复杂操作；

　　在类声明中定义的函数，除了虚函数的其他函数都会自动隐式的当成内联函数。

// 声明1（加 inline，建议使用）
inline int functionName(int first, int secend,...);
// 声明2（不加 inline）
int functionName(int first, int secend,...);
// 定义
inline int functionName(int first, int secend,...) {/****/};

// 类内定义，隐式内联
class A {
    int doA() { return 0; }         // 隐式内联
}

// 类外定义，需要显式内联
class A {
    int doA();
}
inline int A::doA() { return 0; }   // 需要显式内联

编译器对inline函数的处理步骤

　　1　将inline函数体复制到inline函数调用点处；

　　2 为所用inline函数中的局部变量分配内存空间

　　3将inline函数的输入参数和返回值映射到调用方法的局部变量空间中；

　　4如果inlin函数有多个返回点，将其转变为inline函数代码块末尾的分支（使用goto）

优缺点

优点

　　1内联函数同洪函数一样将在被调用处进行代码展开，省去了参数压栈，栈帧开辟与回收，结果返回等，从而提高程序运行速度

　　2内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。

　　3在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。

　　4内联函数在运行时可调试，而宏定义不可以

缺点

　　1代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。

　　2inlin函数无法随着函数库升级而升级，inlin函数改变需要重新编译，不像non-inline可以直接链接。

　　3是否内联，程序员不可控。内联函数只是对编译器的建议，是否函数内联，决定权在于编译器。

虚函数（virtual）可以是内联函数（inline）吗？

　　虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。

　　内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法直到运行期间调用那个代码，因此虚函数表现为多态时（运行期）不可以内联。

　　inline virtal 唯一可以捏脸的时候是：编译器知道所调用的对象是那个类（如Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。

#include<iostream>
using namespace std;
class base
{
   public:
       inline virtual void who()
        {
           cout<<"i AM BASE\n";
    
         } 
        virtual ~Base() {}
};    

class Derived : public Base
{
public:
    inline void who()  // 不写inline时隐式内联
    {
        cout << "I am Derived\n";
    }
};

int main()
{
    // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 
    Base b;
    b.who();

    // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。  
    Base *ptr = new Derived();
    ptr->who();

    // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
    delete ptr;
    ptr = nullptr;

    system("pause");
    return 0;
} 

assert()

断言，是宏，而非函数。assert宏的原型定义在<assert.h>(C)、<assert>(C++)中，其作用是如果它的条件返回错误，则终止程序执行。可以通过NDEBUG来关闭assert，但是需要在源代码的开头，include<assert.h>之前。

#define NDBUG  //这行可以使assert不可用
#include<assert.h>
assert(p!=NULL);//assert不可用

sizeof()

　　sizeof对数组，得到整个数组所占空间大小

　　sizeof对指针，得到指针本身所占空间大小

 

pragme pack(n)

设定结构体，联合以及类成员变量以n字节方式对其

#pragma pack(push)//保存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
    char m1;
    double m4;
    int m3;
    char c1;
};
#pragma pack(pop)//恢复对齐方式

test t1;
cout << sizeof(t1) << endl; //结果为20

位域

bit mode: 2;//mode 占 2 位

类可以将其（非静态）数据成员定义为位域(bit-field),在一个位域中含有一定数量的二进制位。当一个程序需要向其他程序或硬件设备传递二进制数据时，通常会用到位域。

　　-位域在内存中的布局时与机器有关的

　　-位域的类型必须是整形或枚举类型，带符号类型中的位域的行为将因具体实现而定

　　-取地址运算符（&）不能作用于位域，任何指针都无法指向类的位域；

volatile

volatile int i= 10;

　　volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统，硬件，其他线程等）更改。所以使用volatile告诉编译器不应对这样的对象经行优化。

　　volatile关键字声明的变量，每次访问时都必须从内存中取出值（没有被volatile修饰的变量，可能由于编译器的优化，从CPU寄存器中取值）

　　const 可以是 volatile（如只读的状态寄存器）

　　指针可以是volatile

extern "C"

被extern限定的函数或变量是extern类型的

被extern “C”修饰的变量和函数是按照C语言方式编译和链接的

可以必满C++因为符号修饰导致代码不能和C语言库中的符号进行链接的问题。

#ifdef __cplusplus
extern "C" {
#endif

void *memset(void *, int, size_t);

#ifdef __cplusplus
}
#endif

struct 和 typedef struct

c中

typedet struct student

{

int age;

}s;

等价于

struct student{

　　int age；

}；

typedef struct Student S;

此时 S 等价于 struct Student，但两个标识符名称空间不相同。

另外还可以定义与 struct Student 不冲突的 void Student() {}。

// cpp
struct Student { 
    int age; 
};

void f( Student me );       // 正确，"struct" 关键字可省略

二、若定义了与 Student 同名函数之后，则 Student 只代表函数，不代表结构体，如下：

typedef struct Student { 
    int age; 
} S;

void Student() {}           // 正确，定义后 "Student" 只代表此函数

//void S() {}               // 错误，符号 "S" 已经被定义为一个 "struct Student" 的别名

int main() {
    Student(); 
    struct Student me;      // 或者 "S me";
    return 0;
}

C++中的struct和class

总的来说，struct更合适看成是一个数据结构的实现体，class更适合看成是一个对象的实现体；

区别

　　最本质的一个区别就是默认的访问权限

　　　　默认的继承访问权限。struct是public的，class是private

　　　　struct作为数据结构的实现体，

union 联合

联合union是一种节省空间的特殊的类，一个union可以由多个数据成员，但是在任意时刻只能由一个数据成员有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：

　　-默认访问控制符位public

　　-可以含有构造函数，析构函数

　　-不能含有引用类型的成员

　　-不能继承自其他类，不能作为基类

　　-不能含有虚函数

　　-匿名union在定义所在作用域可以直接访问union成员

　　-匿名union不能包含protected成员或private成员

　　-全局匿名联合必须是静态（static）的

#include<iostream>
using namespace std;
union uniontest {
    uniontest() :i(10) {};//拷贝构造 i为10
    int i;
    double d;
};
static union {
    int i;
    double d;
};
int main() {
    uniontest u;
    union {//匿名联合的定义
        int i;
        double d;
    };
    cout << u.i << endl;//输出uniontest联合的10
    ::i = 20;
    cout << ::i << endl;//输出全局静态匿名联合的20
    i = 30;
    cout << i << endl;//输出局部匿名联合的30
    system("pause");
    return 0;
}

explicit（显式）构造函数

explicit修饰的构造函数可以用来防止隐式转换

explicit使用

#include<iostream>
using namespace std;
class test1 {
public:
    test1(int n) {
        num = n;
    }
private:
    int num;
};
class test2 {
public:
    explicit test2(int n)
    {
        num = n;
    }
private:
    int num;
};

int main() {
    test1 t1 = 12;//隐式调用其构造函数，成功
    //test2 t2 = 12;//编译错误，不能隐式调用其构造函数
    test2 t2(12);//显式调用成功
    system("pause");
    return 0;
}

friend友元类和友元函数

能访问私有成员

破坏封装性

友元关系不可传递

友元关系的单向性

友元声明的形式及数量不受限制

using

using声明

一条using声明语句一次只引入命名空间的一个成员，它使得我们可以清楚的知道程序中所引用的到底是那个名字。如：using namespace_name::name;

构造函数的using声明（c++11）

在c++11中，派生类能够重用其直接基类定义的构造函数

class derived:base{
public:
   using base::base;
   //.....  
};

如上using声明，对于基类的每个构造函数，编译器都生成一个与之对应（形参列表完全相同）的派生类构造函数。生成如下类型构造函数：

derived(parms):base(args){ }

尽量少使用using指示 污染命名空间

一般来说，使用using明亮比使用using编译命令更安全，这是由于它只导入了制定的名称。如果该名称与局部名称发生冲突，编译器将发出指示。using编译命令导入所有的名称，包括可能并不需要的名称。如果与局部名称发生冲突，则局部名称将覆盖名称空间版本，而编译器不会发出警告。另外，名称空间的开放性意味着名称空间的名称可能分散在多个地方，这使得难以准确的知道添加了那些名称。

 

::范围解析运算符

分类
1全局作用符（::name）:用于类型名称（类，类成员，成员函数，变量等），表示作用域为全局命名空间
2类作用域符（class::name）：用于表示制定类型的作用域范围是具体某个类的
3命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
：：使用

int count = 0;//全局（：：）的count
class A{
public:
      static int count;//类A的count
};
int main(){
      ::count = 1;//设置全局的count的值为1
      A::count = 2；//设置类A的count为2     
      int count = 0;    // 局部的 count
      count = 3;        // 设置局部的 count 的值为 3
      return 0;
}

enum枚举类型

限定作用域的枚举类型

enum class open_modes{imput,output,append};

不限定作用域的枚举类型

enum color{red ，yellow，green}；

enum{floatPrec=6，doublePrec = 10}；

decltype

decltype关键字用于检查实体的声明类型或表达式的类型及值分类。语法：

decltype（expression）

decltype使用

// 尾置返回允许我们在参数列表之后声明返回类型
template <typename It>
auto fcn(It beg, It end) -> decltype(*beg)
{
    // 处理序列
    return *beg;    // 返回序列中一个元素的引用
}
// 为了使用模板参数成员，必须用 typename
template <typename It>
auto fcn2(It beg, It end) -> typename remove_reference<decltype(*beg)>::type
{
    // 处理序列
    return *beg;    // 返回序列中一个元素的拷贝
}

引用

左值引用

常规引用，一般表示对象的身份

右值引用

右值引用就是必须绑定到右值（一个临时对象，将要销毁的对象）的引用，一般表示对象的值。

右值引用可实现转移语义（move sementics）和精确传递（perfect forwarding），它的主要目的有两个方面：

　　消除两个对象交互时不必要的对象拷贝。节省运算存储资源，提高效率

　　能够更简洁明确的定义泛型函数

引用折叠

• X& &、X& &&、X&& & 可折叠成 X&
• X&& && 可折叠成 X&&

宏

宏定义可以实现类似于函数的功能，但是它始终不是函数，而宏定义中括弧中的参数也不是真的参数，在宏展开的时候参数进行的是一对一的替换。

成员初始化列表

好处

更高效：少了一次调用牧人构造函数的过程

有些场合必须要用初始化列表：

　　常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面

　　引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面

　　没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化。

initializer_list列表初始化 C++11

用花括号初始化器列表，列表初始化一个对象，其中对应构造函数接受一个std::initoalizer_list参数

#include<iostream>
#include<vector>
#include<initializer_list>
template<class T>
struct s {
    std::vector<T> v;
    s(std::initializer_list<T> l) :v(l) {
        std::cout << "constructed with a" << l.size() << "-element list\n";

    }
    void append(std::initializer_list<T> l) {
        v.insert(v.end(), l.begin(), l.end());
    }
    std::pair<const T*, std::size_t>c_arr() const {
        return{ &v[0],v.size() };//在return语句中复制列表初始化，这不适用std::initializer_list
    }
};
template<typename T>
void templated_fn(T) {}
int main() {
    s<int> s = { 1,3,2,4,5 };//复制初始化
    s.append({ 6,7,8 });//函数调用中的列表初始化
    std::cout << "size is now" << s.c_arr().second << " ints:\n";
    for (auto n : s.v)
        std::cout << n << ' ';
    std::cout << '\n';
    std::cout << "range-for over brace-init-list:\n";
    for (int x : {-1, -2, -3})
        std::cout << x << ' ';
    std::cout << std::endl;
    auto al = { 10,11,12 };
    std::cout<< "The list bound to auto has size() = " << al.size() << '\n';
    // templated_fn({1, 2, 3}); // 编译错误！“ {1, 2, 3} ”不是表达式，
                             // 它无类型，故 T 无法推导
    templated_fn<std::initializer_list<int>>({ 1,2,3 });//ok
    templated_fn<std::vector<int>>({ 1,2,3 });
    system("pause");
    return 0;
}