目录

一、面向对象

1、C++发展

2、为什么学C++？

3、面向对象与面向过程

4、面向对象语言的三要素

二、C到C++过度

1、作用域限定符（::）

2、命名空间

（1）如果一个函数里面经常要访问某个命名空间的成员，通过using关键词识别，这样操作这个成员的时候就不需要命名空间来访问了。

（2）在一个函数中如果已经对某个命名空间的成员通过using 标识，就不能再对其它同名的不同的命名空间的成员进行标识

（3）如果再一个代码中都要使用某一个命名空间中的成员，可以通过using标识整个命名空间，这样，这个命名空间中的所有成员都可以访问，一般放在最上面。

3、输入/输出函数（cout/cin）

4、register 关键字

C与C++的不同点：

5、struct 关键字

C与C++的不同点：

6、bool类型

7、三目运算符

C与C++的不同点：

8、const关键字

C与C++不同点：

9、C++引用

（1） 概念： c++提供了给变量取别名的机制，就是引用，引用时对c语言的一个扩充

（2）引用的本质：常指针

（3）引用作为函数的返回值

（4）指针引用（给指针取别名）

（5）常引用

10、内联函数

注意事项：

11、C++函数中默认参数

12、C++函数中占位参数（一般与默认参数一起使用）

一、面向对象

ubuntu:安装g++编译器

命令：sudo apt-get install g++

1、C++发展

C++98标准 -----> C++03------>C++11------>C++14

2、为什么学C++？

应用领域： 应用软件开发 游戏开发 多媒体开发 人工智能

3、面向对象与面向过程

C语言：面向过程

（1）强调做算法

（2）大程序被分割成很多小程序，这些小程序被称为函数

（3）数据开放特点（封装性差）

C++：面向对象

特点：

（1）面向对象按照类来分隔组织程序，每个类都有特定的属性和方法，使得软件就像搭积木一样，更加容易组织

（2）维护代码的更少修改

4、面向对象语言的三要素

封装：把客观的事物封装成类，并且类中实现自己的数据和方法，对于不可信的进行信息隐藏。

继承：类和类之间的关系，省去了重复开发的时间

多态：同一个接口，不同的功能，也称为多种形态

二、C到C++过度

1、作用域限定符（::）

作用域限定符（域解析符）：主要用于操作全局定义的变量或者类或者函数等等。

#include   //标准输入输出流
using namespace std;
int num = 100;
void test1()
{
    printf("num = %dn",num);   //两种输出效果相同
    cout<<"num = "<2、命名空间 
目的：为了解决合作开发或者不同代码端之间的命令冲突问题，c++因此引入命名空间的概念
 
使用注意事项：
 
（1）如果一个函数里面经常要访问某个命名空间的成员，通过using关键词识别，这样操作这个成员的时候就不需要命名空间来访问了。 
（2）在一个函数中如果已经对某个命名空间的成员通过using 标识，就不能再对其它同名的不同的命名空间的成员进行标识 
void test2()
{
    //如果一个函数里面经常要访问某个命名空间的成员，通过using关键词识别，这样操作这个成员的时候就不需要命名空间来访问了
    using zhangsan::num;
    cout<<"张三的num:"< 
（3）如果再一个代码中都要使用某一个命名空间中的成员，可以通过using标识整个命名空间，这样，这个命名空间中的所有成员都可以访问，一般放在最上面。 
using namespace zhangsan;
void test3()
{
    cout< 
 
3、输入/输出函数（cout/cin） 
输入，输出:cin,cout
 
#include  //头文件：输入输出流
using namespace std;  //使用标准命名空间
void test1()
{
    int a = 100;
    printf("a = %cn",a);
    int ch = 'w';
    printf("ch = %cn",ch);
    char b = 'w';
    char c[] = "hello world";
    float d = 3.141592685;
    cout<<"a = "<>a;  //>>：输入运算符
    cout<4、register 关键字 
作用:被register关键词声明的对象直接放在寄存器，大大提升了变量的访问速率
 
C与C++的不同点： 
C语言中：register关键词修饰的变量不可以用&操作符取地址
 
c++中：可以对一个寄存器变量取地址，register关键词变为无效，会被强制放入内存中存储（成为普通变量）
 
5、struct 关键字 
C与C++的不同点： 
C语言中：内部不允许定义函数
 
C++中：可以定义函数；struct命名的结构体名字可以直接作为类使用；
 
//定义一个结构体
struct chinese
{
    char name[32];

//c语言中内部不允许定义函数
//c++可以
    void myfun()
    {
        printf("hello world!n");
    }
};

struct USA
{
    char name[32];
};

//C语言代码
void IntroChinese(struct chinese *ch)
{
    printf("%s是一个中国人n",ch->name);
}
void IntroUSA(struct USA *ch)
{
    printf("%s是一个外国人n",ch->name);
}
int main(int argc, char const *argv[])
{
    struct chinese ch = {"张三"};
    struct USA u = {"BOB"};
    IntroChinese(&ch);
    IntroUSA(&u);
    
    return 0;
}


//C++代码
void IntroChinese(chinese *ch)
{
    printf("%s是一个中国人n",ch->name);
}
void IntroUSA(USA *ch)
{
    printf("%s是一个外国人n",ch->name);
}
int main(int argc, char const *argv[])
{
    chinese ch = {"张三"};
    USA u = {"BOB"};
    IntroChinese(&ch);
    IntroUSA(&u);
    
    return 0;
}
 
6、bool类型 
true 为 1；false 为 0；（占一个字节）
 
#include 
using namespace std;
//c++支持bool类ing，可以赋值为true,或者false,占一个字节
int main(int argc, char const *argv[])
{
    bool a = true;
    cout<<"a = "<
 
7、三目运算符 
C与C++的不同点： 
C语言:三目运算符返回的是一个常量
 
C++：返回的是一个变量
 
#include 
using namespace std;
int main(int argc, char const *argv[])
{
    int a = 1,b = 2;
    int num = (a > b)?a:b;
    
    (a > b)?a:b = 100;  //C语言中，返回的是一个数值，c++中，返回的是一个变量
    return 0;
}
 
8、const关键字 
C与C++不同点： 
C语言：const修饰的是只读变量，但是可以通过地址来修改其值。
 
C++：是一个真正的常量，不可以通过地址或者变量来修改其值，因为其存放在符号表中，所以也就是说，不能对其取地址；但是当对const修饰的变量取地址的话， 系统会为其分配一定内存空间，并且用常量来填充。
 
 
 图中 a 的值是不变的，也就是说，C++中 不可修改。
 
#include 
using namespace std;

int main(int argc, char const *argv[])
{
    const int a = 1;
    //a++;
    int *p = (int *)&a;  
//对const修饰的常量取地址，编译器会分配一个整形的长度，并且把数字1填写到对应的内存中
    *p = 2;
    cout<<"a = "<
 
9、C++引用 
（1） 概念： c++提供了给变量取别名的机制，就是引用，引用时对c语言的一个扩充 
《注意》：typedef:是给数据类型取别名，不能对变量进行重命名。
 
下面是通过引用实现，两个数的互换：
 
 
 
int &c = a;  //引用一定要初始化
 //int &d = 100;   //不能用常量初始化引用
 
#include 
using namespace std;

void Swap(int &x,int &y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
int main(int argc, char const *argv[])
{
    int a = 100,b = 200;
    cout<<"交换前："<<"a = "<
 
（2）引用的本质：常指针 
当分析复杂语法现象的时候,当作常指针来分析，分析一般语法，当别名分析
 
struct test
{
    int &a;   //其相当于一个常指针，大小为8个字节，两个为16个字节
    char &c;
};

int main(int argc, char const *argv[])
{
    int a = 1;
    char c = 'c';
    int &pa =a;
    char &pc = c;
    //int &pb = c;   //左右类型要一致

    cout<<"sizeof(test) = "<（3）引用作为函数的返回值 
注意：引用作为函数的返回值时，不能返回局部数据（局部变量，局部对象，局部数组等）的引用，因为当函数调用完成后，局部数据都会被销毁，数据不存在了。可以返回一个全局变量或者静态变量的引用。
 
将引用作为函数返回值的函数，有4中处理方式：
 
1> 不接收函数返回值
 
2> 用一个普通变量接收函数返回值，这个时候接收的是变量的值而不是变量的引用
 
3> 用一个引用接收函数返回值，接收的就是一个引用
 
4> 当成左值使用
 
#include 
using namespace std;
int g = 100;

int& f1()
{
    int x = 1;
    return g;
}

int main(int argc, char const *argv[])
{
    //用法1：不接受函数返回值
    f1();
    //用法2：用一个普通变量去接收函数的返回值,返回的是g的值
    int a = f1(); 
    a = 1000;
    cout<<"a = "<
 
（4）指针引用（给指针取别名） 
用指针引用代替二级指针：
 
#include 
#include 
#include 

using namespace std;

typedef struct student{
    int id;
    char name[32];
}ST;

void ceate_student(ST* &stu)   //取代了二级指针
{
    stu = (ST *)malloc(sizeof(ST));
    if(stu == NULL)
    {
        cout<<"malloc error"<id = 100;
    strcpy(stu->name,"bxp");
}

void printf_student(ST *stu)
{
    cout<<"id = "<id<<" name = "<name< 
（5）常引用 
常引用：指不能通过引用来改变引用对象的值
 
使用方法：
 
1>使用普通变量初始化常引用
 
int a;
const int &b = a; //b是a的常引用，a和b代表同一块内存空间，但是不能通过b修改a的值
 
2>使用常量初始化常引用（不可以用常量初始化普通引用）
 
const int &num = 10;
 
#include 
using namespace std;
int main(int argc, char const *argv[])
{
    int a =1;
    const int &b = a;
    //b = 2;  //不能通过常引用修改其值
    const int &pb = 100;   //可以用常量初始化常引用
    //int &pd = 100;   //不可以用常量初始化普通引用
    int *p = (int *)&pb;
    (*p)++;
    //pb++;
    cout<<"pb = "< 
10、内联函数 
内联函数：在编译时将函数调用处直接用函数体替换，类似于C语言中的宏展开。这种在函数调用处直接嵌入函数体的函数叫做内联函数（内嵌函数/内置函数）
 
内连函数创建方法：只需要在函数定义处增加关键字inline。
 
#include 
using namespace std;
//只需要在函数定义处加关键词inline即可
inline int MyMax(int a,int b)
{
    return (a > b) ? a: b;
}
#define MAX(a,b) (a) > (b) ? (a):(b)
int main(int argc, char const *argv[])
{
    int a = 1,b = 2;
    cout<注意事项： 
1>.不能存在任何形式的循环语句
 
2>.不能存在过多的条件判断语句
 
3>.函数体不能过于庞大
 
4>.不能对函数进行取地址操作
 
5>.函数内联声明必须在函数调用之前
 
总结:内联函数比普通函数省去了函数调用时压栈，跳转，和返回等开销，因此，当函数体的开销远大于压栈，出栈等开销时，内联函数会变得没有意义。
 
11、C++函数中默认参数 
c++中可以给形参一个默认的值，当我们在使用函数时，如果不传参，则使用这个默认值。
 
使用方法：
 
默认参数：将一个值设置为默认参数，那么右边所有的参数都必须设置默认值
 
如果给默认参数传参，则使用传的参数，不使用默认值
 
#include 
using namespace std;

//默认参数：将一个值设置为默认参数，那么右边所有的参数都必须设置默认值
//如果给默认参数传参，则使用传的参数，不使用默认值
void Add(int x,int y = 0,int z = 1)  //设置y的默认值为1，int y = 1被称为默认参数
{
    cout<<"x + y = "< 
12、C++函数中占位参数（一般与默认参数一起使用） 
占位参数没有初始值时，函数调用时需要传参。
 
void Add(int a,int b,int = 0)   //一般和默认参数一起使用
{
    cout<