C++基础（一）

一、C++简介

（1）C++是一种面向对象语言。
（2）面向对象是把一个问题分解成各个对象，建立对象是为了描述某个事物在整个解决问题的步骤中的属性、行为。
（3）面向对象三大特性：封装、继承、多态。

二、常用关键字

1、namespace

命名空间内可以声明、定义：变量、函数、类。
可以使用同名命名空间补充。

2、using

#include <iostream>
//using namespace std;

namespace test{
    int a = 100;
    int b = 200;
    void showInfo()
    {
        std::cout << "hello world!" << std::endl;
    }
    namespace text{
        int x = 10;
    }
}
namespace test{		//可以直接使用同名对命名空间进行补充
    int c = 99;
}
int main()
{
    std::cout << "a = " << test::a << std::endl;//	：：域名解析符
    test::showInfo();

    std::cout << "x = " << test::text::x << std::endl;//命名空间嵌套逐级访问即可
    using test::a;//具体导入a变量
    using namespace test;//命名空间全部导入
    std::cout << "a = " << a << std::endl;
    std::cout << "b = " << b << std::endl;
    std::cout << "b = " << b << std::endl;
    showInfo();
    return 0;
}
}

打印结果如下：

3、bool

bool 布尔类型只有两种状态，即：
	真-->true-->1
	假-->false-->0

4、string

#include <iostream>
using namespace std;

int main()
{
    string name = "wo yue wei le ? ";
    string speak = "wo mei yue wei ! ";
    cout << "one: " << name + speak << endl;
    name += speak;
    cout << "two: " << name << endl;
    return 0;
}

5、struct

C++中的结构体与C中不同之处

#include <iostream>
using namespace std;
struct Stu
{
    string name;
    int age;
    void write_code()
    {
        cout << "正在努力写代码" << endl;
    }
};
//C++中的struct是具有封装性，默认的访问权限是public:公有访问权限。
//C++中的struct是可以在结构体内部声明并定义函数。也被称为结构类内部的成员函数。或称这类中的行为或方法。
int main()
{
    Stu stu = {"zhangsan",18};
    cout << stu.name << endl;
    cout << stu.age << endl;
    stu.write_code();
    return 0;
}

6、&的使用

#include <iostream>
using namespace std;
void showInfo()
{
    cout << "hello" << endl;
}
struct Stu
{
    void showInfo()
    {
        cout << "world" << endl;
    }
};
int main()
{
    void (*pfunc)() = showInfo;
    pfunc();
    //获取成员函数指针的方式：& + 类域::成员函数名
    void (Stu::*pfunc1)() = &Stu::showInfo;
    Stu stu;
    //成员函数指针回调的方式：
    (stu.*pfunc1)();
    return 0;
}

7、const

当const修饰的变量被一个一个常量赋值，那这个const修饰的变量也被称之为一个符号常量。（直接替换，不可修改，常量没地址，变量才有）

三、内联函数

1、define的缺点

#include <stdio.h>
#define MAX(x,y) x>y?x:y
int main(){
	int a = 1;
	int b = 2; 
	int my_max = MAX(a,++b);// ++ 操作执行了2次
	printf("%d\n",my_max);//4  
	return 0;
}

2、内联函数的使用

（1）使用inline关键字进行修饰，内联函数。
（2）内联函数需要符合内联的特性才能最终成为编译器中的内联函数：1.代码要精简；2.函数内部不可以有递归、循环、或耗时操作等的不附合内联要求。
（3）内联函数的特性，如同宏函数类似，不过内联函数是在编译阶段进行展开。
（4）在C++中所有函数或者类中的成员函数，只要是符合内联要求的，编译器在进行发布版编译时，都会自动加上inline关键字。
（5）内联函数的代价：最终可执行程序的代码膨胀问题。
（6）内联函数适合场景：那些代码简短、调用频繁的函数代码块。（符合内联的特性。）

3、内联与宏函数的区别

（1）内联函数在编译时展开，宏在预处理时以字符串的形式直接替换展开；
（2）内联函数直接嵌入到目标代码中，宏只是简单的文本替换；
（3）内联函数有类型检测、语法判断等功能，而宏没有；
（4）inline函数是函数，而宏不是。

四、C++中的函数参数默认值

函数参数默认值的赋值规则：从右往左依次入栈，所以是从右往左依次给定默认值，不能跳跃。

int add(int a , int b = 100,int c = 100)
{
    return a + b + c;    
}
int main()
{
    int x = 100;
    int y = 200;
    int z = 300;
    cout << add(x,y,z) << endl;
    //已初始化可不再传参
    cout << add(x,y) << endl;
    cout << add(x) << endl;
    return 0;
}

五、重载

1、函数重载定义

当同名函数在同一作用域下，函数的形参类型、形参个数、形参顺序不同，那么这个同名函数当被调用时会根据实参的类型、个数、顺序不同而形成重载关系，与返回值无关。
在底层重载是编译器根据函数的形参类型、形参个数、形参顺序不同，重新生成了函数名，最终调用函数名不同。

六、引用

1、引用定义

引用是使用const修饰的指针。
引用的最大的使用场景就是函数传参及函数返回值。
当引用作用返回值类型时，那么函数返回值也可以做为左值使用。
左值：可以取地址的址都是左值。右值：不可以取地址的值都右值。
引用是引用的是已经存在一块合法的空间。
引用变量即是引用空间的变量的别名。

2、代码展示

#include <iostream>
using namespace std;
void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
void swap(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}
static int c;
int& add_leftvalu(int a,int b)
{
    c = a + b;
    return c;
}
int main()
{
    int x = 100;
    int y = 200;
    //使用引用的形式：
    int& z = x;
    cout << "&z的地址：" << &z << endl;
    cout << "&x的地址：" << &x << endl;
    swap(x,y);
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
    //返回值为引用时可以作为左值使用。
    cout << add_leftvalu(x,y) << endl;
    add_leftvalu(x,y) = 5000 ;
    cout << c << endl;
    return 0;
}

3、常引用

常引用：可以提高函数的传参效率，同时也可以保障传参过程中实参的数据安全。

七、C++中动态开辟空间的方式

#include <iostream>
using namespace std;
int main()
{
    //1.C++的中动态开辟空间方式：
    //只开辟空间，没有初始化堆上空间中的值。
    int* p1 = new int;
    //2.开辟空间并进行初始化：
    cout << *p2 << endl;
    //3.只开辟连续的多个空间，不初始化：
    int* p3 = new int[1024];
    //4.开辟多个空间并初始化。全部初始化为0
    int* p4 = new int[1024]();
    //5.C++11中的方式:开辟多个空间，并初始化
    int* p5 = new int[1024]{1,2,3};
    //堆上内存回收的方式：
    delete p1;
    delete p2;
    //如果是多个连续堆上空间的资源的回收：
    delete [] p3;
    delete [] p4;
    delete [] p5;
    return 0;
}

1、malloc与new之间的关系

（1）new的底层就是用malloc实现的。
（2）malloc如果申请空间失败返回NULL。
（3）new 如果申请空间失败抛出异常 bad_alloc()。
（4）new就是按类型开辟空间的，而malloc是按字节为单位开辟空间的。
（5）对自定义类型来讲：new 不仅开辟空间，还会调用自定类中的构建函数。delete 不仅释放空间，还会在释放空间前先调用类中析构函数。