无痛c到c++ - 技术栈

头文件

跟C语言一样，C++的源码文件前面一般都会包含头文件的预处理语句

c 复制代码

#include <iostream> // c++标准头文件
#include <cmath>    // 在标准名字空间做了声明的改进版math.h
#include <unistd.h> // 无cunistd版头文件
#include <head.hpp> // *.hpp后缀头文件

三种风格

C++的标准头文件无需后缀。

C++可以接收C语言风格后缀的头文件（如#include <math.h>），但如有可能，要优先使用C++版本的头文件（如#include ），两者的内容基本是一样的，但后者中的标识符在标准名字空间 std 中均有声明（除了宏之外）。

C++也接收新风格后缀（如*.hpp）。

名字空间

cpp 复制代码

using namespace std//使用名字空间std中的标识符

其中的主要目的就是尽可能的防止符号命名冲突

由于这些符号（变量、函数、对象）是名字空间 std 中被声明的，因此它们的实际名称应该是：

std::cout

std::cin

std::cerr

std::string

在程序中如果我们不使用 using 语句来导入名字空间符号，那么就必须写这些符号的全名

cpp 复制代码

#include <iostream>
int main(void)
{
    std::cout << "helloworld" << std::endl;
}

标准输入输出cout

cpp 复制代码

cout << "HelloWorld" << endl;//标准输入，需要经过缓冲区
cerr << "HelloWorld" << endl;//不经过缓冲区

字符串string

在c++中引入了字符串变量主要有以下用法

cpp 复制代码

// 字符串的赋值
string s1 = "abdc";

// 字符串的复制
string s2;
s2 = s1;

// 字符串的拼接
string s3;
s3  = "xyz" + s1;
s3 += "123";

// 字符串的比对
if(s1 == "abcd")
    cout << s1 << " == abcd" << endl;
else if(s1 > "abcd")
    cout << s1 << " > abcd" << endl;
else if(s1 < "abcd")
    cout << s1 << " < abcd" << endl;

// 字符串中的元素引用
s1[1] = 'B'; // 将s1修改为"aBcd"

引用

概念：给一个已有对象取一个别名

cpp 复制代码

int   a = 100;
int &ra = a; // 从此之后，a 跟 ra 是同一个变量，代表同一块内存
// 以下代码具有等价的作用
 a = 200；
ra = 200;

引用必须在定义的同时赋值，不可单独定义引用，例如 int &r; 是错误的。

引用一方面提高了数据传输的效率，另一方面简化了数据表达的样式（跟指针相比）

新式类型转换

cpp 复制代码

const_cast<char *>(a);
static_cast<char *>(a);
dynamic_cast<char *>(a);

const_cast<char *>(a);

含义：去除标识符的限定属性const或者volatile ，并且只能用于指针或者引用类型

cpp 复制代码

#include <iostream>
using namespace std;

int main()
{

    int i = 8;
    const int &ri = i;//不科修改

    ri = 9;//语句出现错误

    const_cast<int &>(ri) = 9;//语句正确并可以进行修改

    ri = 9;//语句出现错误
    return 0;
}

sayic_case<char *>(a)

static 意味着静态转换，静态的含义是操作的过程只发生在编译阶段 ，而不是运行阶段，静态转换不涉及类型推理。

可以使程序更加安全

增加程序的可读性

auto关键字

在传递一些的函数有的时候时不缺定的，使用auto自动获取类型

cpp 复制代码

// 以下函数是一个模板，接收一个类型为 T 的容器
// 注意：类型 T 是动态的，可变的，不定的。
template <typename T>
void show(T &container)
{
    // 利用 auto 动态获取未知类型容器的相关数据
    auto it = container.begin();
    ...
    ...
}

函数的默认参数

cpp 复制代码

void f(int a, float b = 3.14);

int main()
{
	// 显式给 b 传递参数1.23
    f(100, 1.23);

	// 使用 b 的默认值3.14
    f(200);
}

void f(int a, float b)
{
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;

}

注意

默认值必须是在声明时进行赋值

默认值必须从右往左进行赋值，避免二义性

函数重载

在C语言中，相同作用域内的重名函数会引起冲突，哪怕它们拥有不同的参数列表也不行，而在C++中，重名函数只要满足一定的要求，可以同时存在，这大大拓展了函数设计的灵活性。这种重名且可并存的语法机制，被称为函数重载。

形成重载的情形

参数列表不同

参数类型不同

类方法的const属性可以构成重载

普通指针和常目标指针

cpp 复制代码

类方法的const属性可以构成重载
class somecls
{
	void f(int a){}
	void f(int a)const{}
}

cpp 复制代码

普通指针和常目标指针**权限只能缩小，不可以被放大**
void f(int *a)

void f(const int * a)

不能形成重载的情形

函数名、函数参数列表完全一致。

函数的返回值类型差异。

静态函数声明（static）。

const型变量（包括常指针）。

堆内存管理

在C语言中，使用 malloc() 和 free() 来分配和释放堆内存，这两个函数在C++中也一样可用，但C++有更好的API来实现这一功能

cpp 复制代码

new();//分配内存--------malloc/calloc
delete();//释放内存-----free

cpp 复制代码

//分配多块内存(1000)
char *k = new char[1000];//分配
delete [] k;//*[]*代表分配了多块内存

差别

cpp 复制代码

#include <iostream>
#include <cstdlib>

using namespace std;

class A
{
public:
    A(){cout << "我是构造函数" << endl;}
};

int main()
{
    A a; //直接定义类会调用构造函数
    
    //使用c将类放入堆空间
    A *b = (A * )malloc(sizeof(A));//不会调用构造函数

    //使用new进行分配
    A *c = new(A);//会调用回回调函数
}

申请类类型的内存时，new 会自动调用类的构造函数，而 malloc() / calloc() 不会。
释放类类型的内存时，delete 会自动调用类的析构函数，而 free() 不会。

枚举循环

cpp 复制代码

#include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
    int a[3] = {1,2,3};

    // 枚举数组a中的各个元素，并输出它们
    for(int i : a)
        cout << i << endl;

    return 0;
}

对于这种具有确定元素个数的数组、容器或集合，都可以使用枚举循环来逐个遍历元素。C++11以后版本才支持的特性。