1.1 概念

C++是一门基于C语言的面向对象编程语言，它可以描述事物的行为，方便程序的设计和维护，但也有一定的性能开销。

面向对象编程的三大特性是封装、继承和多态。

第一章 C++基础_字符串

概念介绍：

  1. 封装 ：将零散的数据和算法放到一个集合里，方便管理和使用。
  2. 复用性：公共功能、过程的抽象，体现为能被重复使用的类、方法，就要求我们针对某一类功能而不是针对某一个功能去设计。
  3. 扩展性：增加新的功能不影响原来已经封装好的功能。
1.2 输入、输出
#include<iostream>  //引入文件，已经包含了#include<stdio.h>
using namespace std;  //打开标准命名空间 std

int a = 0;
char b = 'b';

cout << a  << "      " << b << endl;  //cout: 某个类型 (ostream) 的变量
                    //<<: 输出操作符，本质上是函数
                    //endl: 换行，本质上是一个函数

cin >> a >> b;    //cin: 某个类型 (istream) 的变量
          //>>: 输入操作符，本质上是函数
1.3 命名空间

作用域运算符**: :**，作用域: :成员 指明了成员的归属范围，如果 :: 前不加任何作用域，代表取全局作用 域。常用的作用域有命名空间、结构体、类等。

namespace 命名空间名
{
 变量...
 函数...
 结构体...
};

使用命名空间

  1. using 编译指令打开命名空间，using namespace 命名空间，这是一种懒惰的做法，打开一次里面的成员将全部对外开放。打开了多个命名空间如果成员名相同会出现二义性。
  2. 显示指定命名空间成员，命名空间::成员，这种方式简单直接，如：std::cout<<10;，但是每次使用的时候都需要指明命名空间
int A = 30;    //全局中的变量

namespace abc    //定义一个作用域
{
    int A = 10;    //作用域中的变量
}

int main()
{
    int A = 20;
    cout << A << endl;    //结果：20（局部优先）
    cout << abc::A << endl;    //结果：10
    cout << ::A << endl;    //结果：30（全局成员）

    return 0;
}
1.4 动态申请空间

C和C++中都可以用动态内存分配来操作堆区，但是C中需要用malloc和free函数，并且要指定空间大小，而C++中可以用new和delete关键字，并且只要指定类型，系统会自动计算空间大小，并返回相应类型的指针。格式：type * pointer = new type。

//动态申请空间，堆区
int * p2 = new int;
*p2 = 20;
cout << *p2 << endl;
delete p2;  //释放空间
p2 = NULL;

int* p3 = new int();  //默认初始化，初始化为当前类型的默认初始值
cout << *p3 << endl;
delete p3;  //释放空间
p3 = NULL;

int* p4 = new int(30);  //指定初始化值
cout << *p4 << endl;
delete p4;  //释放空间
p4 = NULL;

char* p5 = new char[3]0;  //首元素的地址,默认初始化
delete[]p5;  //加[]
p5 = NULL;

char* p6 = new char[3]{'1','2','\0'};  //指定值初始化
cout << p6 << end1;  //12
delete[]p6;  //加[]
p6 = NULL;

两者的区别：

  1. malloc-free 本质上是函数，需要对应的头文件支持，new-delete 关键字，需要编译器支持
  2. malloc 需要传递申请空间的大小，返回泛型指针 (void*), 多数情况下需要强转为我们所需要的类型，而 new 后接类型(自动计算大小) ，返回的是申请类型的地址。
  3. new 申请空间可以指定初始化值。
  4. (重要原因) new 申请 结构体、类空间，会自动调用构造函数，delete 会调用析构函数, malloc 只是单纯的申请空间，不会调用构造函数，free 不会调用析构函数
1.5 bool

BOOL使用需要调用 #include <windows.h>

typedef int BOOL;
#define FALSE 0
#define TRUE 1

//c++ 的关键 bool true false
bool a = true;

bool BOOL 区别:

  1. bool, true, false是关键字 BOOL 是 typedef
  2. bool定义变量所占空间大小为1个字节，BOOL为 4个字节
1.6 string

string 是 C++提供的字符串存储、操作的类需要包含头文件并打开std命名空间。其支持字符串的初始化、赋值、比较、拼接、下标访问等操作。

#include <string>
using namespace std;

//改变字符串中的某一元素
string str = "123456";
str[1] = 'a';    //1a3456

//改变整个字符串的内容
string str = "123456";
str = "asdf";    //asdf

//字符串拼接
string str3 = str1 + str2;

str += "000";

//字符串的截取
string str1 = "qwert";
string str2 = str1.substr (1,3);  //取str3左边第1位置起，3字长的字符串 (wer)

size() ，length() 则返回字符串的长度（字符数量）。 将string 类型转换为字符指针，用：

const char *c_str()
1.7 增强的范围for

通常我们遍历数组时，常用的写法for ( ; ; )，新标准允许了下面简化的写法：

type arr[n];

for(type val:arr) //== type val = arr[i]

增强的for循环这种遍历方式，适用于普通的数组、string、和支持 begin , end操作的容器等。

1.8 函数重载

函数参数：C++中允许函数的参数列表指定默认值，而且这个默认值必须从右向左依次指定，不能间断，一般在函数的声明中去指定。

void fun(int a, int b= 30); //函数声明

void fun(int a, int b)    //函数定义
{ 
  cout << a << " " << b << endl;
}

在同一个作用域，函数名一样，参数列表不同（参数类型、数量、顺序等不同）。函数重载描述的是多个函数之间的关系。

void fun();
void fun(int , char) ;
void fun(int , int) ;
void fun(int , int ,int) ;
1.9 nullptr

我们在使用指针的时候，要尽量避免野指针的存在，即定义了就要初始化，如果暂时不知道具体指向 哪块空间，那么可以初始化为空，我们有两种方式 NULL 和 nullptr

int *p1 = NULL;

在C++中 NULL 被如下定义：

//stio.h
/* Define NULL pointer value */
#ifndef NULL
#ifdef __cplusplus
#define NULL 0

NULL 本质上是一个宏，替换了0，出现了一个整型和指针之间的一个混用问题 nullptr C++ 中提供的关键字，代表空指针

1.10 引用

定义引用，对某个已存在变量（空间）起别名。引用必须初始化，且引用一旦引用了某个变量就不能重新引用其他变量了。

int a = 0;
int& b = a;

引用与被引用的变量指的是同一块内存空间，对引用操作就是对原变量进行操作。 引用不是值不占用内存空间，且引用一旦被初始化，就不能再重新引用其他空间。

引用和指针的区别：

  1. 引用定义了就要初始化，指针可不用初始化（但不推荐）。
  2. 引用初始化后就不能再重新引用其他的变量、空间，指针可以随意指向
  3. 有NULL的指针，没有NULL的引用
  4. 指针变量额外占用空间，引用不额外申请空间
  5. 指针可以有多级，但引用只能有一级

第一章 C++基础_初始化_02

函数传参

函数传参的三种方式：值传递、指针传递、引用传递 如果想修改实参，不能用值传递，可以选择指针传递、引用传递，值传递额外申请的空间大小不确定，不可控 指针传递大小可控，引用不额外申请空间，推荐引用，避免值传递