C++基础01----->C++对C的扩展

C++对C的拓展：

1、C++helloworld（cout、cin）

2、面向对象helloworld（类、对象、成员函数）

3、为什么要引入成员函数

4、新增“namespace”

5、增强实用性（变量定义）

6、增强“register”

7、增强“检测”

8、增强“struct”

9、新增类型“bool”

10、增强三目运算符

11、增强“const”

12、新增“引用”

13、函数增强

 

 

1、C++helloworld（cout、cin）

C语言中：用printf。

#include<iostream>
using namespace std;

void main()
{
    //c
    printf("请输入一个数字:\n");

    //c++
    
    //cout 标准输出  代表黑屏幕<--代码；
    //endl--换行
    //cin 标准输入 代表黑屏幕——>代码
    double num;
    cout << "请输入一个数字："<<endl;           
    cin >> num;                          
    cout << "获取到的数字是：" << num << endl;

    system("pause");
}

2、面向对象helloworld（类、对象、成员函数）

C语言中struct：没有成员函数。

抛砖: c++编译器是如何处理 多个对象,调用类的成员函数的;具体一点:如何区分是c1 c2 c3 调用了getS？

//类是一个数据类型,(固定大小内存块的别名); 定义一个类,是一个抽象的概念,不会给你分配内存
//用数据类型定义变量的时候,才会分配内存
class MyCicle
{
public:
    double    m_s; //圆的面积 属性 成员变量
    double    m_r; //圆的半径

public:
    void setR(double r) //成员函数
    {
        m_r = r;
    }

    double getR() //成员函数
    {
        return m_r;
    }
    double getS()
    {

        m_s = 3.14*m_r*m_r;
        return m_s;
    }
};
void main()
{
    MyCicle c1, c2, c3;
    double r=0;
    double s = 0;
    cout << "请输入圆的半径：";
    cin >> r;
    c1.setR(r);
    cout << "圆的面积是：" << c1.getS() << endl;
    system("pause");
}

3、为什么要引入成员函数

class circle
{
public:
    double r;
    double pi = 3.1415926;
    double area = pi * r*r;
};

// 2010编译不通过 但是在2013编译器能编译通过
int main()
{
    circle c1;
    cout << "please input your r" << endl;
    cin >> c1.r;

    cout << c1.area << endl;    //乱码

    system("pause");
    return 0;
}

分析：

4、新增“namespace”

1）在C++中，名称（name）可以是符号常量、变量、宏、函数、结构、枚举、类和对象等等。为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。

2）std是c++标准命名空间，c++标准程序库中的所有标识符都被定义在std中，比如标准库中的类iostream、vector等都定义在该命名空间中。

3） 当使用<iostream.h>时，相当于在c中调用库函数，使用的是全局命名空间，也就是早期的c++实现；

4） 当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。若不引入using namespace std ,需要这样做。std::cout。

#include<iostream>
using namespace std;

//1文件中iostream 没有引入标准的 std ; 需要我们程序员手工的写
//2 如果不写 using namespace std; 需要显示的引入std

//void main()
//{
//    std::cout << "namespace test" << std::endl;
//
//    system("pause");
//}

//3 定义命名空间
namespace  namespaceA
{
    int a = 10;
}
namespace  namespaceB
{
    int a = 20;
    namespace namespaceC
    {
        struct Teacher
        {
            char name[32];
            int age;
        };
    }
}
//4 使用命名空间
//
void main()
{
    using namespace namespaceA;
    using namespace namespaceB;
    cout << namespaceA::a << endl;
    cout << namespaceB::a << endl;
    //方法1
    namespaceB::namespaceC::Teacher t1;
    t1.age = 33;
    cout << t1.age << endl;
    //方法2：
    using namespaceB::namespaceC::Teacher;
    Teacher t2;
    t2.age = 36;
    cout << t2.age << endl;

    system("pause");
}

5、增强实用性（变量定义）

C语言中的变量都必须在作用域开始的位置定义！！
C++中更强调语言的“实用性”，所有的变量都可以在需要使用时再定义。

#include<iostream>
using namespace std;
void main()
{
    int i;
    printf("hello...\n");

    int k;//C语言中k在这里定义式不合法的！

    i = 10;
    k = 11;
    printf("i:%d k:%d \n", i, k);
    system("pause");
}

6、增强“register”

register关键字：请求“编译器”将局部变量存储于寄存器中，速度快。

在c语言中： register修饰的变量 不能取地址。

在C++中：依然支持register关键字，C++编译器有自己的优化方式，不使用register也可能做优化。

C++中可以取得register变量的地址，C++编译器发现程序中需要取register变量的地址时，register对变量的声明变得无效。

void main()
{
    register int a = 0;
    printf("&a: %d \n", &a); //不能在寄存器变量上取地址

    for (int i = 0; i < 1000; i++) //不使用register也可能做优化
    {
        printf("i:%d \n", i);
    }
    system("pause");
}

7、增强“检测”（同名变量、类型检测）

1、同名变量检测：

在C语言中，重复定义多个同名的全局变量是合法的
在C++中，不允许定义多个同名的全局变量
C语言中多个同名的全局变量最终会被链接到全局数据区的同一个地址空间上
int g_var;
int g_var = 1;

C++直接拒绝这种二义性的做法。

2、类型检测

C语言中：函数f的返回值是什么类型、参数又是什么类型、函数g可以接受多少个参数，都没有很严格的规范

C++中：所有的变量和函数都必须有类型。C语言中的默认类型在C++中是不合法的。

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

 f(a)
{
    printf("a = %d\n", a);
}
g()
{
    return 5;
}
int main()
{
    f(10);
    printf("g() = %d\n", g(1, 2, 3, 4, 5));
    system("pause");
    return 0;
    
}

在C语言中：

int f( )；表示返回值为int，接受任意参数的函数

int f(void)；表示返回值为int的无参函数

在C++中：

int f(  );和int f(void)具有相同的意义，都表示返回值为int的无参函数

8、增强“struct”

C语言中：struct定义了一组变量的集合，C编译器并不认为这是一种新的类型，使用时：struct Teacher t1；

C++中：struct是一个新类型的定义声明。使用时：Teacher t1；（不需要加struct）

struct Teacher
{
    int age;
};
void main()
{
    Teacher t1;
    t1.age = 10;
    cout << "t1.age:" << t1.age << endl;
    system("pause");
}

struct 关键字 class关键字 完成的功能是一样的
区别后面介绍 抛砖

class  c1
{
public:
protected:
private:
};
struct Teacher
{
public:
    char name[32];
    int age;
protected:
        int a;
};

9、新增类型“bool”

C++中的bool可取的值只有true和false

bool只占用一个字节

    bool b1 = true;  //告诉c++编译器给我分配 1个字节的内存
    bool b2, b3, b4, b5;
    //
    cout << "sizeof(bool)" << sizeof(bool) << endl;

    //bool变量 1 或者 0
    b1 = 10;
    cout << "bl:" << b1 << endl;

    //bool变量 1 或者 0
    b1 = -10;
    cout << "bl:" << b1 << endl;

    //bool变量 1 或者 0
    b1 = 0;
    cout << "bl:" << b1 << endl;

10、增强三目运算符

1）C语言返回变量的值 C++语言是返回变量本身

C语言中：三目运算符返回的是变量值，不能作为左值使用

C++中：三目运算符可直接返回变量本身，因此可以出现在程序的任何地方

注意：三目运算符可能返回的值中如果有一个是常量值，则不能作为左值使用。(a < b ? 1 : b )= 30;

2） 如何做到的

让表达式返回一个内存空间 ..内存首地址 指针
在C语言中 如何 实现 c++的效果

3）本质

c++编译器 帮我们程序员完成了 取地址的工作

int main()
{
    int a = 10;
    int b = 20;

    //返回一个最小数 并且给最小数赋值成3
    //三目运算符是一个表达式 ，表达式不可能做左值
    (a < b ? a : b) = 30;
    //int z = (a < b ? a : b );

    //C++如何在C基础上做到的
    //实质：c++编译器 帮我们程序员完成了取内存空间地址的工作
   //*(a < b ? &a : &b) = 30;

    printf("a = %d, b = %d\n", a, b);
    system("pause");
    return 0;
}

11、增强“const”

1）const基础知识

#include<iostream>
using namespace std;

void main()
{
    const int a=1 ;
    int const b=2;
    
    const int* c=(int*)&a;//const修饰的是指针所指向的内存空间不能被修改,但指针变量本身可修改
    int* const d= (int*)&b;
    const int* const e= (int*)&b;

    c = (int*)&b;
    *d = 3;

    cout << b << endl;
    cout << *c << endl;
    cout << *d << endl;
    cout << *e << endl;
    system("pause");
}

复杂数据类型

struct Teacher
{
    char name[64];
    int age=18;
};

//指针所指向的内存空间,不能被修改
int  operatorTeacher01(const Teacher *pT)
{
    //pT->age = 10;//不能修改
    return pT->age;
}

//指针变量本身不能被修改
int  operatorTeacher02(Teacher * const pT)
{
    pT->age = 10;
    //pT = NULL; //no
    return pT->age;
}

int  operatorTeacher03(const Teacher * const pT)
{
    //pT->age = 10; no
    //pT = NULL; //no
    return pT->age;
}

void main()
{
    Teacher t1;
    cout<<operatorTeacher01(&t1)<<endl;
    cout << operatorTeacher02(&t1) << endl;
    cout << operatorTeacher03(&t1) << endl;
    system("pause");
}

2）C语言中：const是一个冒牌货，

C++语言中：const是一个真正的常量（符号表机制）

void main()
{
    const int a = 10;
    //a = 11;  no

    //C++中const是一个真正的常量
    //在C中只要取地址再复制依然可以修改const变量的值

    int* p = (int*)&a;
    *p = 20;
    cout << a << endl;
    cout << *p << endl;

    /*解释：
    C++编译器对const常量的处理
    当碰见常量声明时，在符号表中放入常量 = è问题：那有如何解释取地址
    编译过程中若发现使用常量则直接以符号表中的值替换
    编译过程中若发现对const使用了extern或者&操作符，则给对应的常量分配存储空间（兼容C）
    */
    system("pause");

}

const分配内存的时机 编译器编译器期间 

//如何证明：b的地址是在a、c中间
void main()
{
    int a;
    const int b=10;
    int c;
    cout << "&a=" << &a << endl;
    cout << "&a=" << &b << endl;
    cout << "&a=" << &c << endl;
    system("pause");
}

3）const 和 #define的相同与区别

const 和 #define的相同之处：都能处理array[a+b]语法

#define d 20
void main()
{
    int a = 10;
    int b = 20;
    //int array[a + b];//linux内核里面是成立的;原因 编译linux内核的gcc编译器支持.
                    //c和c++编译器 不支持这种语法现象 

    const int c = 10;
    //const int d = 20;
    int array[c + d];
    system("pause");
}

const 和 #define的区别

const常量是由编译器处理的，提供类型检查和作用域检查
宏定义由预处理器处理，单纯的文本替换

void fun1()
{
    #define a 20 // 即使main不跑fun1，#define都会被预处理器处理
    const int b = 20;//此时b的作用域是在fun1里面，const常量是会被编译器检查的
    //#undef  a 
    //# undef
}

void fun2()
{
    printf("a = %d\n", a);
    //printf("b = %d\n", b);
}

int main()
{
    //fun1();
    fun2();
    system("pause");
    return 0;
}

 

结论：

C语言中const变量是只读变量，有自己的存储空间

C++中的const常量可能分配存储空间,也可能不分配存储空间  

当const常量为全局，并且需要在其它文件中使用

当使用&操作符取const常量的地址

 

12、新增“引用”

1）引用的基础知识

一、引用的概念：

• 对一段连续的内存空间可以取多个别名，
  引用可以看作是一个已定义变量的别名，也就是给内存空间起别名
• 注意：普通引用必须初始化

#include<iostream>
using namespace std;

void main()
{
    int a = 10;

    //引用的语法：Type& name = var;

    int &b = a;//与a共用一个内存空间
    //int &b;//普通引用 必须要初始化

    b = 100;//相当于把a修改成100了
    cout << a << endl;
    cout << b << endl;

    a = 200;
    cout << a << endl;
    cout << b << endl;
    system("pause");
}

二、引用是C++的概念，不能用c语言的语法去思考它

• 思考1：C++编译器背后做了什么工作？

int main()
{
    int a = 0;
    int &b = a; //int * const b = &a (C++编译器自动取a的地址)
    b = 11;  //*b = 11;（用到b时C++编译器自动变成*b）

    return 0;
}

三、引用作函数参数：（引用作为函数参数声明时不用进行初始化）

• 基础数据类型的引用

//基础类型的引用 
void myswap(int a, int b)
{
    int c = 0;
    c = a;
    a = b;
    b = c;
}
void myswap02(int *a, int *b)
{
    int c = 0;
    c = *a;
    *a = *b;
    *b = c;
}
// 引用作为函数参数声明时不进行初始化
void myswap03(int &a, int &b)
{
    int c = 0;
    c = a;
    a = b;
    b = c;
}
void  main()
{
    int x, y;
    x = 10;
    y = 20;

    myswap(x, y);
    cout << x << y << endl;

    myswap02(&x, &y);
    cout << x << y << endl;

    //a就是x的别名  b就是y的别名
    myswap03(x, y);
    cout << x << y << endl;

    //int &c ; //普通引用 必须要初始化
    system("pause");
}

• 复杂数据类型的引用

//复杂数据类型 的引用
struct Teacher
{
    char name[64];
    int age;
};

void printfT(Teacher *pT)
{
    cout << pT->age << endl;
}

//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
    //cout<<pT.age<<endl;
    pT.age = 33;
}

//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{    
    pT.age = 45; //只会修改pT变量 ,不会修改t1变量
    cout << pT.age << endl;
}
void main()
{
    Teacher t1;
    t1.age = 35;

    printfT(&t1);

    printfT2(t1); //pT是t1的别名
    cout << t1.age << endl; //33

    printfT3(t1);// pT是形参 ,t1 copy一份数据 给pT     //---> pT = t1
    cout << t1.age << endl;//33

    system("pause");
    return;
}

2）引用的本质

• 第一点 单独定义的引用时，必须初始化；说明很像一个常量

void main()
{
        
        const  int c = 10;
        
        int a = 10;
        int &b = a;  //b很像一个常量
        //b是a的别名，请问c++编译器后面做了什么工作？
        b = 11;
        
        cout << "a:" << a << endl;
        cout << "b:" << b << endl;
        cout << "&a:" << &a << endl;
        cout << "&b:" << &b << endl; //===> a 和 b就是同一块内存空间的门牌号
        
        system("pause");
        return;
}

• 普通引用有自己的空间吗？ 有 

//2 普通引用有自己的空间吗？ 有 
struct Teacher
{
    char name[64]; //64
    int age; //4 

    int &a; //4 0  //很像指针 所占的内存空间大小
    int &b; //4 0 
};

void main()
{
    cout << sizeof(Teacher) << endl;
    system("pause");
}

• 引用的本质：

　　一、引用在C++中的内部实现是一个常指针

     　　　　Type& name====Type* const name

　　二、C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。

 

　　间接赋值成立的三个条件的角度：

　　1定义两个变量 （一个实参一个形参）

　　2建立关联 实参取地址传给形参

　　3*p形参去间接的修改实参的值

• 进一步，引用的结论：

　　一、引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一

　　　　当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）

　　二、当我们使用引用语法的时，我们不去关心编译器引用是怎么做的

　　　　当我们分析奇怪的语法现象的时，我们才去考虑c++编译器是怎么做的。

 

3）引用做函数返回值（左值右值都可以当）

返回引用是基础类型：

• 若返回栈变量，不能成为其它引用的初始值，不能作为左值使用

#include<iostream>
using namespace std;

int getAA1()
{
    int a;
    a = 10;
    return a;
}

//返回a的本身 返回a的一个副本 10 
int& getAA2()
{
    int a; //如果返回栈上的 引用, 有可能会有问题
    a = 10;
    return a;
}

int* getAA3()
{
    int a;
    a = 10;
    return &a;
}

void main()
{
    int a1 = 0;
    int a2 = 0;
    a1 = getAA1();//返回的是a的值

    a2 = getAA2(); //10  返回的也是a的值，并非a的地址
    int &a3 = getAA2();  //若返回栈变量    不能成为其它引用的初始值
                        //一执行取地址的操作就有问题 乱码
    //getAA2()=11；//不能当左值

    int* a4 = getAA3();//乱码

    cout << a1 << endl;
    cout << a2 << endl;
    cout << a3 << endl;
    cout << *a4 << endl;
    system("pause");
}

• 若返回静态变量或全局变量，可以成为其他引用的初始值，即可作为右值使用，也可作为左值使用

　　　C++链式编程中，经常用到引用，运算符重载专题

//变量是static 或者是 全局变量
int j1()
{
    static int a = 10;
    a++;
    return a;
}

int& j2()
{
    static int a = 10;
    a++;
    return a;
}
//若返回静态变量或全局变量
//    可以成为其他引用的初始值
//    即可作为右值使用，也可作为左值使用
void main()
{
    int a1 = 10;
    int a2 = 20;
    //当右值
    a1 = j1();
    a2 = j2();
    int &a3 = j2();

    //当左值：
    j2() = 100;

    cout << a1 << endl;//11
    cout << a2 << endl;//11
    cout << a3<< endl;//12

    system("pause");
}

返回引用是非基础类型（结构体、类），后面讲

4）指针引用

用法：int* &myp=地址；（可以用来代替二级指针）

#include "iostream"
using namespace std;

//
struct Teacher
{
    char name[64];
    int age;
};

//在被调用函数 获取资源 
int getTeacher(Teacher **p)//二级指针用来接一级指针的地址
{
    Teacher *tmp = NULL;
    if (p == NULL)
    {
        return -1;
    }
    tmp = (Teacher *)malloc(sizeof(Teacher));
    if (tmp == NULL)
    {
        return -2;
    }
    tmp->age = 33;
    // p是实参的地址  *实参的地址 去间接的修改实参的值
    *p = tmp;
}


//指针的引用 做函数参数
int getTeacher2(Teacher* &myp)
{
    //给myp赋值 相当于给main函数中的pT1赋值
    myp = (Teacher *)malloc(sizeof(Teacher));
    if (myp == NULL)
    {
        return -1;
    }
    myp->age = 36;
}

void FreeTeacher(Teacher *pT1)
{
    if (pT1 == NULL)
    {
        return;
    }
    free(pT1);
}

void main()
{
    Teacher *pT1 = NULL;

    //1 c语言中的二级指针
    getTeacher(&pT1);
    cout << "age:" << pT1->age << endl;
    FreeTeacher(pT1);

    //2 c++中的引用 （指针的引用）
    //引用的本质 间接赋值后2个条件 让c++编译器帮我们程序员做了。
    getTeacher2(pT1);

    cout << "age:" << pT1->age << endl;
    FreeTeacher(pT1);

    system("pause");
}

5）常引用

 

Const & int e  相当于 const int * const e

 

 

13、函数增强