C++快速入门笔记（一）

C++的概述：

C++的诞生地--贝尔实验室（Bell Lab）

C++之父 比雅尼.斯特劳斯特鲁普

生于丹麦

丹麦奥胡斯大学的数学和计算机科学硕士学位

英国剑桥大学的计算机科学博士学位

德州农工程学院的计算机科学首席教授

《The C ++ Programming Language》

C++发展史三个阶段

第一个阶段从80年底到1995年。这一阶段C++语言基本上市传统类型上的面向对象语言，

并且凭借着接近C语言的效率，在工业界使用的开发语言中占据了相当大份额。

第二阶段从1995年到2000年。这一阶段由于标准模板库（STL）和后来的Boost等程序库的出现，

泛型程序设计在C++中占据越来越多的比重性。当然，同时由于Java,C#等语言的出现和硬件的大规模下降，

C++受到了一定的冲击。

第三阶段从2000年至今。由于以LOKi,MPL等程序库为代表的产生编程和模板元编程的出现，C++出现了发展历史上又一个新的高峰，

这些新技术的出现以及和原有技术的融合，使C++已经成为当今主流程序设计语言中最复杂的员。

C++的特性

C语言面向过程

C++面向过程+面向对象（封装、继承、多态）

具备C语言的全部特性，并支持更多新的特性。

C++ I/O方式

#include <iostream>
int main(int argc,const char * argv[]) {
    
    // c语言
    int a =0;
    scanf("%d",&a);
    printf("a = %d",a);
    
    // C++
    char str[20];
    std::cin >> str;
    std::cout <<  str <<std::endl; 

    // 这样的输入，输出方式有哪些便利？
    // 不用关注占位符
    // 不用关注数据类型
    return0;
}

namespace 命名空间

也称“名称空间”、“名字空间”

一种代码组织的形式 通过名称空间来分类，区别不同的代码功能、避免名字冲突。

// 不同的命名空间下允许有相同名称的标识符
namespace A {
    void fun()
    {
        int x =20;
        int y =30;
        std::cout << x + y  <<std::endl;
    }
}
namespace B {
    void fun()
    {
        int x =10;
        int y =90;
        std::cout << x + y  <<std::endl;
    }
}
using namespaceA;// 使用A命名空间
int main(void)
{
    fun();
}

新的数据类型

c语言数据类型

int、char、float、double、longdouble、struct、union、enum、NULL、void、指针类型。

c++

布尔类型（bool）

true  = 1

false = 0

c语言中是没有bool的

要是有需要#include <stdbool.h>

int main(void)
{
    int flag = 1;
    if (flag == 1) {
        // 真
    }else
    {
        // 假
    }
    
    bool flag1 = true;
    if (flag1) {
        // 真
    }else
    {
        // 假
    }

    return 0;
}

C++中的引用

中华人民共和国      中国  别名

C++中的引用就是变量的别名

普通类型引用的定义与使用

int main(void)
{
    int kdskkksdkjdskkdsjkdsjkdsjk = 8;//名字好长
    int &kkk = kdskkksdkjdskkdsjkdsjkdsjk;
    
    kkk = 8888;
    
    std::cout << kdskkksdkjdskkdsjkdsjkdsjk << std::endl; // 输出8888
    kdskkksdkjdskkdsjkdsjkdsjk = 999;
    
    std::cout << kkk << std::endl; // 输出999
    
    return 0;
}

指针类型引用的定义与使用

int main(void)
{
    int x = 10;
    int *p = &x;
    int *&q = p;
    
    std::cout << *p << std::endl;
    *p = 20;
    
    std::cout << *q << std::endl;
    
    int y= 100;
    q = &y;
    
    std::cout << *p<< std::endl;
    
    *q = 30;
    std::cout << *p<< std::endl;
    return 0;
}

引用作为函数参数

void fun(int *a,int*b)
{
    int c = 0;
    c = *a;
    *a = *b;
    *b = c;
}
void fun(int &a,int &b)
{
    int c = a;
    a = b;
    b = c;
}


int main(void)
{
    int a = 100;
    int b = 200;
    fun(a,b);
    std::cout << a<< ":" << b << std::endl;
    int c = 300;
    int d = 400;
    fun(&c,&d);
    std::cout << c<< ":" << d << std::endl;
    return 0;
}
// 输出 200:100 400:300

函数默认值

void fun(int i,int j = 5,int k = 10);
int main(void)
{
    fun(5);
    fun(4,10);
    fun(10,20,30);
    

    return 0;
}
void fun(int i,int j,int k)
{
     std::cout <<i << " "<< j << "  "<< k << std::endl;
}
//    输出
//    5    5  10
//    4   10  10
//    10  20  30

作用域

void fun1()
{
    int x = 0;
    // x 在 fun1 范围内的作用
}

void fun2()
{
    int x = 1;
    // x 在 fun2 范围内的作用
}

函数重载

在同一个作用域下名字相同，参数不同的多个函数（或者同一个命名空间，同一个类下）

1、重载函数的参数个数，参数类型，产生顺序3者中必须至少有一个种不同，返回值不同不作为重载依据。

2、重载函数的功能应该相近，不为重载而重载。

3、main() 函数不能重载

void fun(int *a,int*b)
{
    int c = 0;
    c = *a;
    *a = *b;
    *b = c;
}
void fun(int &a,int &b)
{
    int c = a;
    a = b;
    b = c;
}
void fun(int i,int j,int k)
{
    
}

void fun(int x)
{
    
}
void fun(char x)
{
    
}
void fun(int x,char y)
{
    
}
void fun(char y,int x)
{
    
}

内存管理

1、栈区（stack）由编译器自动分配释放。

2、全局去（静态区）（static）存放全局变量、静态数据、常量。

3、文字常量区 常量字符串就是放在这里的。程序结束后由系统释放。

4、程序代码区  存放函数体的二进制代码。

5、堆区（heap） 程序员申请/释放

申请内存：new

释放内存：delete

int main(void)
{
    int *p = new int;
    if(p == NULL)
    {
        std::cout << "failed" << std::endl;
    }
    int *q = new int(10);
    int *j = new int[5];
    *p = 10;
    j[0] = 1;
    j[2] = 2;
    std::cout << *p <<std::endl;
    std::cout << j[0] << " "<< j[2]<<std::endl;
    delete q;
    delete p;
    delete [] j;
    j = NULL; //释放完毕的后续工作
    
    return 0;
}

当申请内存忘记释放，就会产生内存泄漏。

永久的记忆

输入和输出都是相对于内存来说的

内存的特点：有电则生，断电则亡。

内存 ->输入、输出 ->持久化载体->普通硬盘、固态硬盘、U盘。

文件输出、输出

#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, const char * argv[]) {
    // ios::out 为输出而打开文件
    // ios::app 将数据添加到文件的尾部。
    // 文件输出
    ofstream myfile("1.txt",ios::out);
    myfile << "hello C++" << endl;
    myfile.close();
    
    //文件输入
    //ios::in 为输入而打开文件
    char ch[10];
    ifstream file("1.txt",ios::in);
    file >> ch;
    
    myfile.close();
    
    cout << ch << endl;
    return 0;
}

常量 const

不能再赋值是常量

const char ch = 'c';

const:是constant单词的简写，是关键字，可以通过修饰一个变量使其成为常量。

    const int x = 0;
    int const y = 0;
    
    const int *p = 0;
    const int *q = 0;
    
    int *const i = 0;
    const int *const j = 0;
    int const *const h = 0;

const 修饰普通数据类型

const int r = 0;// 后面不能再修改r的值

const 修饰指针类型

    int b = 0;
    int t = 0;
    int  const *d = &b;// 修饰的是指针的值不能改变
    // *d = 3 错误
    b = 3;
    d = &t;//不能改变值、但可以改变指针
    int  *const w = &b;// 修饰的是指针不能改变
    //w = &t 错误
    *w = 10;

const 修饰函数参数

void max(int x,int y);
void max(const int x,const int y);//无法修改常量的值
void max(int const *p,int *const q);//指针p不能改变值、指针q不能指向别的变量

思考：#define与const定义常量的区别

#define 预编译器进行简单的字符串替换

const 编译器进行类型检查