C++基础学习笔记 day01

1. C++概述

C++中的++来自于C语言中的递增运算符++，该运算符将变量加1。C++起初也叫“c with class”。通过名称表明，C++是对C的扩展，因此C++是C语言的超集，这意味着任何有效的C程序都是有效地C++程序。C++程序可以使用已有的C程序库。

 C语言和C++并不是对立的竞争关系。

 

2. hello world书写

#include    // 标准输入输出流
using namespace std;  // 使用命名空间 std 打开一个叫std房间

// 函数入口地址

int main()
{
        // cout 标准的输出
        // << 左移运算符
        // endl 结束换行 \r \n C++只有一个结束换行
        cout << "hello world - " << 123 << endl;
}

问题1：C++头文件中为什么没有.h?

在C语言中头文件使用扩展名.h将其作为一种通过名称标识文件类型的简单方式。但是C++的用法改变了，C++头文件没有扩展名。有些C语言的头文件被转换为C++的头文件，这些文件被重新命名，丢掉了扩展名.h（使之成为C++风格头文件），并在文件名称前面加上前缀c（表示来自C语言）。例如：C++版本的math.h为cmath

问题2：using namespae std 是什么？

namespase是指标识符的各种可见范围。命名空间用关键字namespace来定义。命名空间是C++的一种机制，用来把单个标识符下的大量有逻辑联系的程序实体组合到一起。此标识符作为此组群的名字。

问题3：cout、endl是什么？

cout是C++中的标准输出流，endl是输出换行并刷新缓冲区。

 

3. 双冒号作用域运算符

#include  
using namespace std;

int atk = 200;

void test01()
{
        int atk = 100;
        cout << "攻击力为：" << atk << endl;
        // 双冒号 作用域运算符 ::全局作用域
        cout << "全局攻击力为：" << ::atk <

 

4. namespace的使用

主要用途：用来解决命名冲突的问题

1. 命名空间下 可以放函数、变量、结构体、类

2. 命名空间必须定义在全局作用域下

3. 命名空间可以嵌套命名空间

4. 命名空间是开发的，可以随时往原先的命名空间添加内容

5. 匿名（无名）命名空间，相当于写了 static int x；

6. 命名空间可以起别名

namespace very = veryLongName；

 

5. using声明和using编译指令

1. using声明要避免二义性。using KingGlory::sunwukongID

2. 如果打开多个房间，也要避免二义性问题。cout<<LOL::sunwukongID<

 

6. C++对C语言的增强

6.1. 全局变量的检测增强

        int a;

        int a=10;

C语言中全局变量可以编译通过，但是C++中会失败，显示重定义。

6.2. 函数检测增强，参数类型增强，返回值检测增强，函数调用参数检测增强（增强的意思就是必须要有）

int getRectS(int w,int h)
{
    return w*h;
}

6.3. 类型的转换检测增强

void test03()
{
    char *P = malloc(sizeof(64)); //malloc返回值是void *
}

C++中必须要有强制类型转换（char *）malloc（sizeof（64））；

6.4. struct增强

struct Person
{
    int m_Age;
    void plusAge(); // C++中struct可以加函数
}

void test04()
{
    struct Person p1; // C语言使用时必须加入struct关键字
    Person p2; // C++使用的时候可以不加
}

6.5. bool类型增强

C语言中没有bool类型

bool flag = true; // 只有真（1）或假（0）

void test05()
{
    cout << sizeof(bool) << endl; // 1
    flag = 100;
    cout << flag << endl; // 1
}

6.6. 三目运算符增强

void test06()
{
    int a = 10;
    int b = 20;

    //printf(" ret = %d\n",a>b?a:b);
    cout << "ret = " << (a>b?a:b) << endl; // ret = 20

    cout << "ret = " << (a>b?a:(b=100)) << endl; // ret =100
}

C语言中返回的是值，C++返回的是变量

6.7. const增强

const int m_A = 10; //全局变量和C语言一样。不能修改值，只读

void test07()
{
    const int m_B = 20; // 真正常量，不能修改

    int *p = (int *)&m_B;
    *p = 200;

    cout << "*p = " << *p << endl;  // 200
    cout << "m_B = " << m_B << endl; // 20
}

C语言中，const修饰的变量，是伪常量，编译器是会分配内存的。

C++中，const不会分配内存。

C语言中const默认外部链接，C++默认内部链接（只有当前文件夹下）。

6.8. const分配内存的情况

// 1、const分配内存 取地址会临时分配内存
void test01()
{
    const int m_A = 10;
    int *p = (int *)&m_A;
}

// 2、extern编译器也会给const变量分配内存

// 3、用普通变量初始化const的变量
void test02()
{
    int a = 10;
    const int b = a; // 会分配内存
}

// 4、自定义数据类型
struct Person
{
    string m_Name; // 姓名
    int m_Age;
}

void test03()
{
    const Person p1;
    Person *p = (Person *)&p1;
    p->m_Name = "德玛西亚"；
    (*p).m_Age = 18;

    cout << "姓名：" << p1.m_Name << endl;
    cout << "年龄：" << p1.m_Age << endl;
}

int main()
{
    test03();
}

会不会分配内存就看能不能用指针进行修改值。

 

7. 引用

引用就是取别名！！！

int &b = a;

&写到左侧，叫引用，写到右侧，取地址。

// 1、引用基本语法 Type A别名 = 原名
void test01()
{
    int a = 10;
    int &b = a;
    
    b = 20;
    cout << "a=" << a << endl; // 20
    cout << "b=" << b << endl; // 20
}

// 2、引用必须初始化
void test02()
{
    // int &a;  必须初始化
    int a = 10;
    int &b = a; // 引用初始化后不可以修改了
}

// 3、对数组建立引用
void test03()
{
    int arr[10];
    for(int i = 0; i<10; i++)
    {
        arr[i]=i;    
    }

    // 给数组取别名
    int (&pArr)[10] = arr;
    for(int i = 0; i<10; i++)
    {
        cout << "pArr[i]" << " ";
    }
    cout << endl;

    // 第二种方式，取别名
    typedef int(ARRAYREF)[10]; // 一个具有10个元素的int类型的数组
    ARRAYREF & pArr2 = arr;
}

 

8. 参数的传递方式

// 1、值传递
void mySwap(int a,int b)
{
    int tmp = a;
    a = b;
    b = tmp;
    
    cout << "mySwap::a=" << a << endl; // 20
    cout << "mySwap::b=" << b << endl; // 10
}

void test01()
{
    int a = 10;
    int b = 20;
    mySwap(a,b); // 值传递
    
    cout << "a=" << a << endl; // 10
    cout << "b=" << b << endl; // 20
}

// 2、地址传递
void mySwap2(int *a,int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void test02()
{
    int a = 10;
    int b = 20;
    mySwap2(&a,&b); // 地址传递
    
    cout << "a=" << a << endl; // 20
    cout << "b=" << b << endl; // 10
}

// 3、引用传递（类似传地址）
void mySwap3(int &a,int &b) // &a = a &b =b
{
    int tmp = a;
    a = b;
    b = tmp;
}

void test03()
{
    int a = 10;
    int b = 20;
    mySwap3(a,b); // 引用传递
    
    cout << "a=" << a << endl; // 20
    cout << "b=" << b << endl; // 10
}

引用的注意事项：

1、 引用必须引用一块合法的内存空间；

2、 不要返回一个局部变量的引用

引用的本质在C++内部实现是一个指针常量。

Type & ref = val ; // Type * const ref = &val;

 

9. 引用的应用场景（指针的引用）

C语言：指针的应用

struct Person
{
    int m_Age;
}

void allocatMemoey( Person **p ) // **p 具体的Person对象 *p 对象的指针 p 指针
{
    *p = (Person *)malloc(sizeof(Person));
    (*p)->m_Age = 100;
}

void test01()
{
    Person *p =　NULL;
    allocatMemoey(&p);
    cout << "P的年龄：" << p->m_Age << endl;
}

C++：引用的应用

void allocatMemoryByRef(Person * &p)
{
    p = (Person *)malloc(sizeof(Person));
    p->m_Age = 1000;
}

void test02()
{
    Person *p = NULL;
    allocatMemoryByRef(p);
    cout << "P的年龄：" << p->m_Age << endl;
}

 

10. 引用的应用场景（常量引用）

void test01()
{
    const int &ref = 10; 
    // 加入const后，编译器处理方式为 int tmp = 10; const int ref = tmp;

    // ref = 10; 不能直接修改
 
    int *p = (int *)&ref;
    *p = 1000;

    cout << "ref= " << ref << endl;
}