TCP/IP+mysql复习

目录

TCP/IP 协议

TCP相关考点：

三次握手建立连接

四次挥手断开连接

数据加密算法：

加密模式分类：

数据库：

数据加密算法：

基础语法：

顺序链表：

c++ 中的operator()有两大主要作用：

浅析final

---

TCP/IP 协议

1. SOCK_RAW：原始套接字，可以用来直接访问底层协议（如IP、TCP等），常用于实现网络数据包的过滤、转发、控制等操作。
2. SOCK_DGRAM：数据包式套接字，它是一种无连接的协议，使用UDP协议进行数据传输，主要用于传输数据包，它不需要建立连接，也不保证数据的可靠性，因此常用于实时性要求较高的应用场景。
3. SOCK_PACKET：协议无关的套接字，它可以用来访问底层的网络接口（如以太网、PPP等），可以实现高效的数据收发操作，主要用于驱动程序和网络协议的实现，由于它可以直接访问底层网络接口，因此可以提供更高的数据收发效率和更细粒度的控制。
4. SOCK_STREAM：流式套接字，它是一种面向连接的、可靠的、基于字节流的传输协议，类似于TCP协议，但是比TCP协议更加高效，常用于需要保证数据可靠传输的应用场景，如文件传输、邮件发送等。

TCP相关考点：

TCP协议采用（ 可变滑动窗口）进行流量控制

• TCP传输控制协议：面向连接的、面向字节流的，全双工的，可靠的数据传输服务，数据传输单位为报文段(segment)；TCP连接的端点叫做socket（IP+Port).
• UDP用户数据报协议：无连接的，尽最大努力数据传输服务（不可靠），数据传输单位为用户数据报，一般用在对实时性和传输效率有一定要求的场景（下载，游戏等）

 三次握手建立连接

术语：

SYN：同步位，SYN=1表示进行连接请求

ACK：确认位，ACK=1确认有效，ACK=0确认无效

ack：确认号，对方发过来的序号+1

seq：序号

三次握手建立连接

1. 主动端调用connect发起连接，首先发送一个SYN包（将TCP首部SYN标记置为1），告诉被动端初始化序列号是x，这时主动端进入SYN_SENT状态，被动端处在Listen状态（调用listen后进入此状态）
2. 被动端收到SYN包后回复ACK表明已收到，并发送自己的初始化序列号y（将TCP首部SYN标记和ACK标记都置为1），被动端把这个连接信息放入SYN队列，进入SYN_RCVD状态
3. 主动端收到包后，回复一个ACK确认包，此时双方进入ESATABLISED状态，被动端把这个连接信息从SYN队列移除，并将其放入Accept队列中。

四次挥手断开连接

1. 主动端发送一个FIN包给被动端（TCP首部FIN标志置为1），表示没有数据传输，要求断开连接，这时主动端进入FIN_WAIT_1状态
2. 被动端收到FIN包后，回复一个ACK包，这时被动端进入CLOSE_WAIT状态，主动端收到ACK后进入FIN_WAIT_2状态
3. 被动端没有数据再发送后，也向主动端发送一个FIN包，被动端进入LAST_ACK状态
4. 主动端收到FIN包，并回复一个ACK包，主动端从FIN_WAIT_2状态进入TIME_WAIT状态。

常考三十题：大厂面试常考的30 道计算机网络面试题（含答案） - 知乎 (zhihu.com)

数据加密算法：

对称加密：DES、3DES、AES

非对称加密：RSA、DSA、ECC

加密模式分类：

a. 链式加密算法：将数据分成多个块，对每个块进行加密，并将加密后的块拼接起来形成最终的加密数据，常用的链式加密算法有RC4、RC5等。

b. 迭代加密算法：将数据重复迭代加密，常用的迭代加密算法有AES-CBC、DES-ECB等。

c. 散列加密算法：将数据转换成固定长度的摘要信息，常用的散列加密算法有MD5、SHA等。

数据库：

数据加密算法：

对称密码算法又叫传统密码算法，也就是加密密钥能够从解密密钥中推算出来，反过来也成立。

非对称密钥也叫公开密钥加密,它是用两个数学相关的密钥对信息进行编码。

常见的对称加密算法有：DES、IDEA、AES、SM1和SM4。

常见的非对称加密算法有：RSA、ECC、SM2。

数据执行

在以下情况下可能会读取到脏数据：

1. 事务B读取了A尚未提交的数据。
2. 事务B读取了已经被A更新但尚未提交的数据。
3. 事务B读取了已经被A删除但尚未提交的数据。

丢失更新问题是在多个并发事务同时更新同一数据时出现的。

不可重复读（Non-Repeatable Read）是指在数据库访问中，一个事务范围内两个相同的查询却返回了不同数据。这是由于在读取数据后，另一个事务已经更新了该数据，并且该更新对当前事务可见。

引起写入错误的原因很多，可能是由于软件、硬件、操作系统或应用程序等方面的问题导致。

基础语法：

顺序链表：

顺序表是一种线性表，它用一段连续的存储单元依次存储元素。若要在表头插入一个新元素，需要将表内元素向后移动一位，新元素插入到表头位置，因此移动元素的操作需要进行n次。

代码样例：

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

#define MaxSize 50
typedef int ElemType;

//线性表的顺序存储方式
typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;

//建立顺序表
void CreateList(SqList *&L,ElemType a[],int n)
{
	int i = 0;
	while(i<n)
	{
		L->data[i] = a[i];
		i++;
	}
	L->length=i;
}
//按元素查找
int LocateElem(SqList *L,ElemType x)
{
	int i = 0;
	while(i<L->length && L->data[i]!=x)
		i++;
	if(i>=L->length)
		return 0;
	else
		return i+1;
}
//插入数据元素
bool ListInsert(SqList *&L,ElemType x,int i)
{
	int j;
	if(i<1 || i>L->length)
	{
		printf("不存在该位置");
		exit(0);
	}
	for(j=L->length-1;j>=i-1;j--)
	{
		L->data[j+1]=L->data[j];
	}
	L->data[i-1]=x;
	L->length++;
	return true;
}
 
//删除数据元素
void ListDelete(SqList *&L,int i)
{
	int j;
	if(i<1 || i>L->length)
	{
		printf("不存在该位置\n");
		exit(0);
	}
	for(j=i;j<=L->length-1;j++) 
	{
		L->data[j-1] = L->data[j];
	}
	L->length--;
}

//输出线性表
void DispList(SqList *L)
{
	int i;
	for(i=0;i < L->length;i++)
	printf("%d ",L->data[i]);
	printf("\n");
}

void main()
{
	int a[10];
	int len;
	len = 10;
	SqList *L = (SqList*)malloc(sizeof(SqList));   
	printf("请输入10个整型元素:");
	for(int i=0;i<len;i++)
	{
		scanf("%d",&(a[i]));
	}
    CreateList(L,a,len);
	 
	printf("Sqlist长度=%d\n",L->length);
	printf("Sqlist内元素:");
    DispList(L);

	ElemType x;
	printf("请输入需要插入的元素的位置:");
	int j;
	scanf("%d",&j);
	printf("请输入需要插入的元素:");
	scanf("%d",&x);
	ListInsert(L,x,j);
	printf("Sqlist长度=%d\n",L->length);
	printf("Sqlist内元素:");
	DispList(L);

	printf("请输入需要查找的元素:");
	scanf("%d",&x);
	printf("该元素的位置是%d\n",LocateElem(L,x));

	printf("请输入需要删除的元素的位置:");
	scanf("%d",&j);
	ListDelete(L,j);
	printf("Sqlist内元素:");
	DispList(L);
	printf("Sqlist长度=%d\n",L->length);


}

在分页系统中，采用基本地址变换机构方式，CPU每存取一次数据，需要进行（      2）次访存

分别是访问页表，访问实际物理地址

c++ 中的operator()有两大主要作用：

1. Overloading------重载()操作符；
2. Casting------实现对象类型转化。

#include<bits/stdc++.h>
// 包含了stdc++库的头文件

using namespace std;
// 使用std命名空间，避免在代码中使用频繁的std::

class F
// 定义一个抽象类F，包含一个纯虚函数operator()
{
public:
virtual double operator ()(double x) const=0;
// 声明纯虚函数operator()，用于计算参数x的值，返回值为double类型
};

class Fun:public F
// 定义一个继承自F的派生类Fun，实现纯虚函数operator()
{
public:
double operator()(double x) const
// 重载函数operator()，实现自然对数在x=0处的值计算方法
{
return log(1.0+x)/(1.0+x*x);
}
};

int main()
// 主函数
{
Fun f;
// 创建一个Fun类的对象f
cout<<f(0)<<endl;
// 输出f(0)的值，即自然对数在x=0处的值
return 0;
}

java中的字符串比对：

    public static void main(String[] args) {
        String str="java2";
        String str1="java";
        String str2="2";
        String str3=str1+str2;
        System.out.println(str==str3);
        System.out.println(str.equals(str3));
    }

输出

false
true

浅析final

public static void main(String[] args)  {
  String a = "hello2";
  final String b = "hello";
  String d = "hello";
  String c = b + 2;
  String e = d + 2;
  System.out.println((a == c));
  System.out.println((a == e));
}

大家可以先想一下这道题的输出结果。为什么第一个比较结果为true，而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中，由于变量b被final修饰，因此会被当做编译器常量，所以在使用到b的地方会直接将变量b 替换为它的值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了，不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化

各种排序算法详解：

[算法总结] 十大排序算法 - 知乎 (zhihu.com)

获取对象：

class Person {
   private String name;

   public Person(String name) {
       this.name = name;
   }
   
   public String getName() {
       return name;
   }
   
   public void setName(String name) {
       this.name = name;
   }
}

Person p = new Person(); Class c = p.getClass();

在Java中，getClass()是一个方法，它返回一个对象的运行时类。

Class c = Person.class;

在请求分页管理中，采用FIFO（先进先出）页面置换算法，可能产生（  Belady现象    ）

Belady现象是指在分页式虚拟存储器管理中，发生缺页时的置换算法采用FIFO（先进先出）算法时，如果对一个进程未分配它所要求的全部页面，有时就会出现分配的页面数增多但缺页率反而提高的异常现象。