【C++】基础及引用

输出

#include "iostream" //包含c++的头文件 //iostream.h
using namespace std; //使用命名空间 std 标准的命名空间 (在这个命名空间中定义了很多标准定义)
void main()
{
    //printf("hello....\n");
    //cout 标准输出 黑屏幕,
    //<< 左移操作符  在c++里面 功能的改造(增强)===>C++ 语言操作符重载  //3day
    //endl \n
    //打印到屏幕 并且换行
    cout << "hello...."<<endl;
    system("pause");
}

求圆面积

//在C++中 定义了一个自定义数据类型 MyCicle 圆形
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 main03()
{
    MyCicle        c1, c2, c3; //用类 定义 变量 对象
    double        r;
    cout << "请输入c1圆形的半径:";
    cin >> r;

    //给c1圆形的属性赋值
    c1.setR(r);

    cout << "c1圆形的面积是:" << c1.getS()<<endl;

    system("pause");
}

//用面向对象的方法
//1 类的抽象 成员变量和成员函数
//2 实例化 类的对象
//3 求面积
    //面向过程加工的是 一个一个的函数
    //面向对象加工的是:一个一个的类
//4 main集成测试

//思考1:类的调用 执行过程分析==>类代码不是一步一步指向
//类是一个数据类型,(固定大小内存块的别名); 定义一个类,是一个抽象的概念,不会给你分配内存
//用数据类型定义变量的时候,才会分配内存
//思考2:抛砖: c++编译器是如何处理 多个对象,调用类的成员函数的;具体一点:如何区分是c1 c2 c3 调用了getS,抛砖.....

定义变量的时候，初始值就已经固定下来了，后面需要调用函数才能改变成新的值，成员函数只有调用了才会执行

所谓namespace，是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。

命名空间std封装的是标准程序库的名称，标准程序库为了和以前的头文件区别，一般不加".h"

当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。

命名空间

#include "iostream"
using namespace std;

namespace namespaceA
{
    int a = ;
}

namespace namespaceB
{
    int a = ;
    namespace namespaceC
    {
        struct Teacher
        {
            char name[];
            int age;
        };
    }
}

void main()
{
    using namespace namespaceA;
    using namespace namespaceB;
    cout << namespaceA::a << endl;
    cout << namespaceB::a << endl;

    namespaceB::namespaceC::Teacher t1;
    t1.age = ;
    system("pause");
}

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

2） c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。

3） C++命名空间的定义： namespace name {  …  }

4） using namespace NameSpaceA;

5） namespce定义可嵌套。

C++增强部分

1.C语言中的变量都必须在作用域开始的位置定义！！

C++中更强调语言的“实用性”，所有的变量都可以在需要使用时再定义。

2.register关键字增强 

C语言中无法取得register变量地址

在C++中依然支持register关键字

C++编译器有自己的优化方式，不使用register也可能做优化

C++中可以取得register变量的地址

3.变量检测增强

在C语言中，重复定义多个同名的全局变量是合法的

在C++中，不允许定义多个同名的全局变量

C语言中多个同名的全局变量最终会被链接到全局数据区的同一个地址空间上

4.struct类型加强 

C语言的struct定义了一组变量的集合，C编译器并不认为这是一种新的类型

C++中的struct是一个新类型的定义声明

5.C++中所有的变量和函数都必须有类型

6.新增bool类型

true代表真值，编译器内部用1来表示

false代表非真值，编译器内部用0来表示

负数也是true

在C语言中，表达式返回的是一个数值

在C++中，表达式返回的是变量本身

const在C++中是一个真正的常量，在C中可以通过指针修改

const int c = 5; 约等于 #define c 5

引用可以看做一个已定义变量的别名（C语言没有引用）

#include<iostream>
using namespace std;

void main() {
    int a = ;
    //引用的语法：Type& name = var
    int &b = a;
    b = ;//相当于把a修改成100了
    printf("b:%d \n", b);
    printf("a:%d \n", a);
    system("pause");
}

普通引用在声明时必须用其它的变量进行初始化

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

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

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

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

    printfT(&t1);

    printfT2(t1); //pT是t1的别名
    printf("t1.age:%d \n", t1.age); //

    printfT3(t1) ;// pT是形参 ,t1 copy一份数据 给pT     //---> pT = t1
    printf("t1.age:%d \n", t1.age); //

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

引用的本质

#include <iostream>
using namespace std;
void main() {
    int a = ;
    int &b = a;
    cout << &a<<endl;
    cout << &b<<endl;
    system("pause");
}

a和b是同一块内存空间的门牌号，引用也占空间（4个字节，和数据类型没关系）

引用在C++内部就是一个常量指针&a  a=5 ==  *const a *a=5

#include <iostream>
using namespace std;

void modifyA(int &a) {
    a = ;
}

void modifyB(int * const a) {
    *a = ;
}

void main() {
    int a = ;
    modifyA(a);
    cout << a<<endl;

    a = ;
    modifyB(&a);
    cout << a<<endl;
    system("pause");
}

间接赋值成立的三个条件

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

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

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

引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一（当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针））

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

函数返回若是一个引用，可以当左值

#include <iostream>
using namespace std;

int& g2() {
    static int a = ;
    a++;
    cout << a << endl;
    return a;
}

void main() {
    g2() = ;
    g2();
    system("pause");
}

输出