C/C++知识点

 

 const

作用

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

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

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

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

使用

 1 //
 2 class A
 3 {
 4   private:
 5    const int a;
 6  public:
 7      // 构造函数
 8     A() { };
 9     A(int x) : a(x) { };        // 初始化列表
10 
11     // const可用于对重载函数的区分
12     int getValue();             // 普通成员函数
13     int getValue() const;       // 常成员函数,不得修改类中的 何
14                                     //数据成员的值     
15 } ; 
16 
17 void function()
18 {
19     // 对象
20     A b;                        // 普通对象,可以调用全部成员函数
21     const A a;                  // 常对象,只能调用常成员函数、更新常成员变量
22     const A *p = &a;            // 常指针
23     const A &q = a;             // 常引用
24 
25     // 指针
26     char greeting[] = "Hello";
27     char* p1 = greeting;                // 指针变量,指向字符数组变量
28     const char* p2 = greeting;          // 指针变量,指向字符数组常量
29     char* const p3 = greeting;          // 常指针,指向字符数组变量
30     const char* const p4 = greeting;    // 常指针,指向字符数组常量
31 }
32 
33 // 函数
34 void function1(const int Var);           // 传递过来的参数在函
35 //数内不可变
36 void function2(const char* Var);         // 参数指针所指内容为常量
38 void function3(char* const Var);         // 参数指针为常指针
39 void function4(const int& Var);          // 引用参数在函数内
40 //为常量
41 
42 // 函数返回值
43 const int function5();      // 返回一个常数
44 const int* function6();     // 返回一个指向常量的指针变量,使用:
46 const int *p = function6();
47 int* const function7();     // 返回一个指向变量的常指针,使用:
48 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()),这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。

 1 #include<iostream>
 2 using namespace std;
 3 class base
 4 {
 5    public:
 6        inline virtual void who()
 7         {
 8            cout<<"i AM BASE\n";
 9     
10          } 
11         virtual ~Base() {}
12 };    
13 
14 class Derived : public Base
15 {
16 public:
17     inline void who()  // 不写inline时隐式内联
18     {
19         cout << "I am Derived\n";
20     }
21 };
22 
23 int main()
24 {
25     // 此处的虚函数 who(),是通过类(Base)的具体对象(b)来调用的,编译期间就能确定了,所以它可以是内联的,但最终是否内联取决于编译器。 
26     Base b;
27     b.who();
28 
29     // 此处的虚函数是通过指针调用的,呈现多态性,需要在运行时期间才能确定,所以不能为内联。  
30     Base *ptr = new Derived();
31     ptr->who();
32 
33     // 因为Base有虚析构函数(virtual ~Base() {}),所以 delete 时,会先调用派生类(Derived)析构函数,再调用基类(Base)析构函数,防止内存泄漏。
34     delete ptr;
35     ptr = nullptr;
36 
37     system("pause");
38     return 0;
39 } 

assert()

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

1 #define NDBUG  //这行可以使assert不可用
2 #include<assert.h>
3 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;
}

 

posted @ 2018-12-11 17:03  Road_of_Mike  阅读(218)  评论(0编辑  收藏  举报