C++ primer plus学习笔记(一)——基础语法

绝地灬酷狼 2023-07-18 09:43 23阅读 0赞

### C++ primer plus学习笔记（一）——基础语法 ###

*   *  引言
     *  指针与&、\*
     *  宏定义与内联函数
     *  类型别名
     *  泛型
     *  decltype
     *  const与mutable
     *   *  const
         *  mutable
     *  volatile
     *  thread\_local
     *  register
     *  auto
     *  static与extern
     *  枚举
     *  new与delete
     *   *  使用new申请内存
         *  使用delete释放内存
     *  命名空间
     *  文件IO
     *  array和vector初探

## 引言 ##

本来是java方向的程序员，最近开始学习cpp,刚看到C++ primer plus这本书的第10章，在进入cpp的面向对象学习前，先整理下前面9章的知识笔记，以下内容基于c++11标准

## 指针与&、\* ##

&在c++中的一种作用为取出当前变量在内存的逻辑地址  
\*在c++中的一种作用为取出当前逻辑地址对应的内存空间的值  
c++中提供指针变量存储对象的地址，指针的运算会被编译器优化为地址的运算，比如一个int类型的指针 p+1的值实际是p指向的地址+1个int所占空间大小后的逻辑地址  
指针语法为 typename \* variable，比如

int a = 5;
    int * p = &a;
    *p == 5;//true

而对于结构体指针，可以使用->来操作成员，如

struct data{ 
    	int a = 1;
    }
    data d1 = { 
    	a:2
    };
    data * dp1 = &d1;
    d1.a = 3;
    dp1->a = 5;
    (*dp1).a = 6;

## 宏定义与内联函数 ##

c++中可以在文件头使用\#define进行宏定义，编译器在编译时会将代码里特定字符串替换为宏定义以后的结果，这也是内联函数的实现原理（第6版书中255页，8.1小节），所以内联函数会比较占据内存（多个代码副本），也就是调用内联函数的地方，会被编译器替换为内联函数的执行代码，与宏定义的函数区别是，内联函数更加的严谨，其限定了参数类型及返回值类型  
比如

#define eetal 1
    int a = eetal;//compile as int a = 1;
    #define sum(x,y) (x+y)
    int b = sum(1,2);//compile as int b = (1+2)
    inline int sum(int a,int b){ 
      		 return a+b;
    }

因为宏定义会对文本替换，一般用于定义常量等，为了避免重复宏定义，c++提供了\#ifndef(if not define缩写)命令来判断当前是否进行了某个名称的宏定义，可以根据结果进行处理  
如：

#ifndef eetal
     	//code
     #endif

同时还有用于判断宏定义的\#if

#define a 5
    #if a>5
    	...
    #endif

以上代码代表如果没有定义过eetal这个宏变量，则会执行\#ifndef和最近的endif之间的代码

## 类型别名 ##

与宏定义类似的，c++还提供了typedef可以对类型取别名和定义一些函数指针的别名  
比如

typedef int iint;
    typedef void (*functionPointer)(int a);//接下来代码中

在上述代码之后的代码中使用iint定义变量等价于使用int  
使用functionPointer作为类型可以定义指向 返回值为void，只有一个int形参的函数指针  
c++11标准给using指令也加入了取别名的用法（真希望可以废弃一些旧的用法，太多重复的东西）。上述代码等价于

using iint = int;
    using functionPointer = void (*)(int a);

## 泛型 ##

c++的泛型通过template来设定，泛型方法代表该方法尚未注册实际代码，只有在代码里调用了该方法时，会通过隐式触发或者显示定义或者主动触发来创建对应的方法实例  
方法的匹配规则为 代码中指定泛型方法>普通方法>显示声明>泛型方法  
如

//在一些标准好像typename也会写为class,如下的两种写法swap01和swap02一样
    template<class T> void swap02(T &a,T &b){ 
        T temp = b;
        b = a;
        a = temp;
    }
    
    template<typename T> void swap01(T &a,T &b){ 
        T temp = b;
        b = a;
        a = temp;
    }
    
    //泛型的显示声明，匹配规则（代码中指定泛型方法>普通方法>显示声明>泛型方法）
    template<> void swap01<int>(int &a,int &b);

此时调用如

int a,b;
    swap01(a,b);
    //普通调用，先匹配显示声明
    
    double c,d;
    swap01(c,d);
    //显示声明不匹配类型，触发隐式生成double泛型的方法实例匹配
    
    char e,f;
    swap01<char>(e,f);
    //主动指定方法泛型为char

## decltype ##

因为泛型会导致方法的不安全，比如

template<typename T> void sum(T &a,T &b){ 
        ? c = a+b;
        //do something
    }

因为c++重载了运算符,string类型也可以使用+拼接，那如何确定泛型变量运算返回值的类型呢？于是有了decltype

decltype(a+b) c = a+b;

上述代码代表，如果a+b的表达式合法，c的类型即为他们运算后值的类型，deltype还有一个特殊用法来创建引用

int a;
    decltype((a)) sa = a;//equals to  int & sa = a;

上述代码代表sa的类型为 a的类型 的引用类型，即变量sa此时是a的一个引用

## const与mutable ##

### const ###

const代表常量定义（java里的final），不可修改。因为cpp里面的指针类型定义比较特殊，所以const的位置代表不同含义，如

const int v = 0;//v cantnot be change anymore
    
    struct data{ 
    	int a;
    };
    
    ....
    
    data t1 = { 
    	a = 0;
    },t2 = { 
    	a = 3;
    };
    
    const data * p1 = &t1;
    //p1->a = 4     cannot work, error
    //p1 = p2      it work
    
    data * const p2 = &t2;
    //p2->a = 4     it work
    //p2 = p1      cannot work, error

如上述代码，p1可以修改指向的地址，但是无法通过p1修改单元内容  
p2不可修改指向的地址，但是可以通过p2修改单元内容

### mutable ###

mutable用于标记结构体中不想受结构体的const限制的成员，比如

const struct data{ 
    	int a = 1;
    	mutable int b = 0;
    }
    data * d = new data();
    d->b = 3;//ok
    //d->a = 5;error

上述代码创建了一个结构体data，因为其以const修饰，成员a不能被修改，而因为成员b以mutable修饰，不受限制可以修改

## volatile ##

与java一样消除内存屏障用的，标记告诉编译器不要缓存该变量到寄存器或者线程缓存，每次从内存读取

volatile int a;

## thread\_local ##

用于创建存放在当前线程作用域的对象，该对象存放在当前线程内存，在当前线程存活时间里保持存活

thread_local int a = 1;

## register ##

在c++11标准里代表默认，类似java的default（在以前标准为通知编译器尽量存储到寄存器，不过c++11改了）

## auto ##

在c++11标准代表类型推断，必须在定义时为变量完成初始化，否则无法推断(在旧版本标准为默认，即当前的register作用)

auto a = 1;
    //auto b; error

## static与extern ##

在c++中，在文件的函数外部，及全局便写的变量为全局变量，其他连接的工程文件在代码里可以通过extern关键字引入其他文件的全局变量。  
而static代表标记变量为静态的全局变量，不能被extern发现  
全局变量的生命周期时整个程序运行期间

//1.cpp
    int A = 100;
    static int B = 5;

//2.cpp
    extern int A;//100
    //extern int B; error

## 枚举 ##

c++的枚举存储整数，不指定默认第一个为0后续每个依次递增，整数不能直接赋值给枚举变量，需要通过构造，而枚举变量可以直接赋值给整数

enum langs{ java, cpp};// 0 and 1
    //enum langs{ java=3, cpp=100};// 3 and 100
    langs newLang = langs(1);//cpp
    langs anotherLang = java;
    int howMuch = anotherLang;//0

## new与delete ##

cpp中也是使用new来创建对象（在cpp中比较习惯称为分配内存，c里还有malloc,calloc,realloc）,同时提供释放内存的指令，这会造成很多危险，但是也带来性能的提升

### 使用new申请内存 ###

#include<new>
    int * p = new int();//只申请一个int的空间，返回地址
    int * ap = new int[5];//申请一个5个int元素的数值空间，返回第一个元素地址
    int * p2 = new(p) int();//指定要分配空间的首地址，此种方式要引入new头文件

如上代码，其中ap为数组头，而p2指定了首地址为p1，这样代表其分配的空间覆盖了p1的空间，当尝试申请的内存不够时，在c++11中会抛出异常（以前是返回空地址0）

### 使用delete释放内存 ###

对于普通指针，使用delete 指针删除，而对于数组类型的指针，应当使用delete\[\]来调用数组各个元素的析构函数（基本类型只是释放）,因为p1已经被p2覆盖，所以释放了p2就不能再去释放p1，因为内存已经被回收了

delete p2;
    delete[] ap;

## 命名空间 ##

c++因为大部分代码还是存在面向过程，放在全局的变量的做法，为了方便管理避免重名，引入命名空间，通过命名空间归类方法和变量，比如

namespace std{ 
    istream cin;
    ostream cout;
    }

上述代码创建了一个std的命名空间，里面的对象通过 命名空间::成员名称 使用，比如

std::cin;
    std::cout;

通过使用using命令，指定将命名空间内容加入当前代码块，则可以省略命名空间，如

using namespace std;
    cin;
    cout;

命名空间还可以嵌套

namespace yyt{ 
    	namespace std{ 
    		istream cin;
    		ostream cout;
    	}
    }
    ....
    yyt::std::cin;

对于本文件的全局变量，可以使用匿名命名空间访问成员，如

#include<iostream>
    namespace eetal{ 
    	int a = 10;
    }
    int a = 5;
    int main(){ 
        int a = 3;
        std::cout<<a<<endl;//3
        std::cout<<::a<<endl;//5
        std::cout<<eetal::a<<endl;//10
    	return 0;
    }

## 文件IO ##

文件IO需要通过引入头文件fstream

#inlcude<fstream>
    //输出流ofstream
    ofstream outPutStream;
    outPutStream.open("test.txt");//will clear old content
    outPutStream.write("aaas",4);//writer max 4 characters
    outPutStream.flush();
    outPutStream.close();

//输入流ifstream,
     ifstream inputStream;
     inputStream.open("test.txt");
     char str[5];
     inputStream.read(str,4);//read max 4 characters
     inputStream.close();

## array和vector初探 ##

前10章简单讲了下array是有界的，vactor无界（自动增长），并且可以直接像数组一样使用  
创建语法

#include<array>
    #include<vector>
    
    int size = 5;
    vector<double> doublevWithSize(size);//size is a variable
    array<int,5> array1;//cannot use variable the size must is const
    doublevWithSize[0] = array1[0];

c++类都不大写开头，源码暂时看着很难懂，了解多点后再分析吧

更多文章，请搜索公众号歪歪梯Club  
![更多资料，请搜索公众号编程宝可梦][20200521183346518.jpg]

[20200521183346518.jpg]: /images/20230528/1e2a83790011450cae49366fff459e6e.png