C++---Day03

[TCP-IP详解卷1：协议.pdf](…\Documents\Tencent Files\2240031723\FileRecv\TCP-IP详解卷1：协议.pdf)

1.总结const与指针的关系

2.总结const与引用的关系

3.总结this指针

任务：

1.多线程、多进程

银行家算法，生产者–消费者，读者-写者

多线程线程的同步

哲学家就餐，写一个死锁版本，如何将其改成不死锁版本

银行转账问题，写上两个类型

A客户转给B客户，如何完成转账

互斥量、信号量、共享内存，消息队列，

任选其一剖析其底层实现

2.给一个变量，找到其绝对的物理地址

虚拟地址映射

在Linux下剖析底层malloc的实现

网络：TCP/IP协议第一卷

服务器和客户端如何实现，多线程，多进程

线程池，进程池

#ifdef __cplusplus
#include<iostream>
using namespace std;
#else

#include<stdio.h>
#endif

int main()
{
    const int a = 10;
    int b = 0;
    int *p = (int*)&a;
    *p = 100;
    b = a;//在编译阶段b被替换为10
#ifdef __cplusplus
    cout<<"a = "<<a<<"b = "<<b<<"*p = "<<*p<<endl;
#else
    printf("a = %d b = %d *p = %d \n",a,b,*p);
#endif
}

C和C++的编译方式对常量的认知不同

如何知道编译器是按照不同的方式编译？

C++有四个强转形式：

（1）去常性强转

int *s = const_cast<int*>(&a);

int main()
{
    const int a = 10;
    const int &b = a;
    int& c = (int&)a;
    c += 100;
    return 0;
}

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

int& funref()
{
    int a = 20;
    return a;//a变量已经死亡
}//从失效空间里面获取数据是不安全的
int * const funref()
{
    int a = 10;
    return &a;
}
int y = *funref();
int * const z = funref();
int main()
{
    int x = fun();//10
    int y = funref();//20
    int& z = funref();//随机值 
    cout << x << " " << y << " " << z <<endl;
    return 0;
}

临时量：将亡值

不能从已失效空间获取值

void fun(int* p)//void fun(int*& p)
{
    int a = 10;
    p = &a;//变量的生存期受到函数的影响
}
int main()
{
    int* s = NULL;
    fun(s);//对p本身的修改能不能修改到s---不可以
}

如何把一个变量以引用的形式返回？

使变量的生存期不受函数的影响，函数的生存期不影响变量的生存期

int& fun()
{
    static int a = 10;//.data
    return a;
}

函数的死亡不影响全局变量和静态局部变量的死亡，以及以引入进入的变量

int* fun()
{
    int ar[10] = {12,23,34,45,56,67,78,89,90,100};
    return ar;
    //如果数组的大小改为1000，则主函数可以成功打印出数组的十个值
}
int main()
{
    int *p = fun();//此时p为失效指针
    for(int i = 0;i < 10;++i)
    {
        printf("%p => %d\n",p,*p);
        //为printf函数重新分配栈帧，覆盖数组的值，打印出来的结果为随机值
        p += 1;
    }
    return 0;
}

底层解析时，解析为自身为常性的指针，在定义时要初始化

引用和指针的区别：

从语法，引用是变量的别名

从汇编（底层），引用相当于自身为常性的指针

引用相比指针来说，安全一点

int a = 10;
int &b;
int * const b;
b = &a;

void fun(int &a)
{
    int *p = &a;
    a = 100;
    *p = 200;
}
int main()
{
    int x = 10;
    int &y = x;
    fun(x);
    fun(y);
    return 0;
}

void fun(int * const a)
{
    if(a == NULL)
    {
        return;
    }
    int *p = &a;
    a = 100;
    *p = 200;
}
int main()
{
    int x = 10;
    int * const y = &x;
    fun(&x);
    fun(y);
    return 0;
}

class Rectangle
{
 private:
    int left,top,right,bottom;
 public:
    Rectangle(int e = 0,int t = 0,int r = 0,int b = 0):left(e),top(t),right(r),bottom(b){}
    //作为缺省的构造函数和带参的构造函数
    //实现默认构造函数和带参的构造函数
    //实现Set函数
    void SetLeft(int e)
    {
        left = e;
    }
    void SetTop(int t)
    {
        top = t;
    }
    void SetRight(int r)
    {
        right = r;
    }
    void SetBottom(int b)
    {
        bottom = b;
    }
    //实现Get函数
    int GetLeft() const {return left;}
    int GetTop()  const {return top;}
    int GetRight() const {return right;}
    int GetBottom() const {return bottom;}
    void Show()const
    {
        cout<<"left-top point is (" <<left << "," <<top << ":)" <<endl;
        cout << "right-bottom point is (" <<right << "," << bottom << ")" <<endl;
    }
};

int main()
{
    Rectangle r1;
    Rectangle r2(1,1,20,20);
    
    const Rectangle & r = r2;
    r.GetLeft();
    return 0;
}

准则：

调动构造函数的目的：

（1）进行对象的构建

（2）初始化对象

构造函数和拷贝构造函数使用列表方案对其进行初始化，其他函数不可以，为什么？

列表，初始化列表只能存活于构造函数，拷贝构造函数中

实现双向函数

class Object
{
 private:
    int value;
 public:
    Object(int x = 0):value(X){}
    ~Object(){}
    void SetValue(int x) { value = x};
    int GetValue() {return value;}
    //使用一个函数实现SetValue和GetValue()函数的功能
    //int & Value(Object * const this)
    int& value() {return value;}
    //const int & Value(const Object * const this)
    const int& Value()const {return value;}
    //不能说是函数重载
    //返回值与函数没有联系
};

void fun(const Object &obj)
{
    const int &x = obj.Value();
}
int main()
{
    Object obj(10);
    obj.Value();
    const Object obj(20);
    objc.Value();
    
    Object obj(10);
    int x = 0;
    x = obj.Value();
    obj.Value() = 100;
    
    Object obj(10);
    int x = 0;
    x = obj.value();
    obj.value() = 100;
}