【与C++的邂逅】--- 类与对象(下)

news2024/11/15 15:25:28

 Welcome to 9ilk's Code World

       

(๑•́ ₃ •̀๑) 个人主页:        9ilk

(๑•́ ₃ •̀๑) 文章专栏：     与C++的邂逅 

本节我们继续学习类与对象下，下面给出本节内容大纲。

🏠 再谈构造

📌 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值 。 
class Date
{
public:
 Date(int year, int month, int day)
 {
     _year = year;
     _month = month;
     _day = day;
 }
private:
 int _year;
 int _month;
 int _day;
};
虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，是一种"伪初始化"，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

📌 初始化列表

class Stack
{
public:
	Stack(size_t capacity)
	{
		//..
	}
private:
	int _top;
	int _array;
	int _size;
};

class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
	int _size;
};

int main()
{
	MyQueue q;
	return 0;
}

对于MyQueue这样的类，我们建议构造时使用编译器默认生成的构造，此时对它的自定义类型成员调用默认构造，但是Stack类中由于显示实现了有参构造，此时没有默认构造，该如何对MyQueue类对象初始化呢？

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
此时可以利用初始化列表进行初始化,在初始化列表中显示对自定义类型调有参构造： 
MyQueue(int n) //显示写构造
 :_pushst(n),
  _popst(n),
  _size(0)
{}

对于初始化列表我们需要了解以下几点：

  • 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)，初始化列表本质上可以理解为每个对象中成员定义的地方(毕竟类只能在定义的时候构造). 
class MyQueue
{
public:
   MyQueue(int n) //显示写构造 定义的地方
    :_pushst(n),
     _popst(n),
     _size(0)
   {}

private:  //声明
	Stack _pushst;
	Stack _popst;
	int _size;
};
  • 类中所有成员既可以在初始化列表初始化，也可以在函数体；但以下类型必须在初始化列表初始化：
1. const成员变量。(const修饰变量只有一次初始化机会，需要在定义时给他一个值)
2. 引用成员变量。(引用定义时需要给他一个值，而且不能改变指向)
3.无默认构造的自定义类型成员。(这类成员必须显示传参调构造)
  • 尽量使用初始化列表初始化。因为不管你是否显示写，成员变量都会走初始化列表，自定义类型调用它的默认构造。

  • 缺省值是给初始化列表准备的。

1. 内置类型有缺省值初始化列表用缺省值，没有的话不确定，看编译器，有的编译器会处理，有的不会处理。

2. 自定义类型成员初始化列表会调用默认构造(没有默认构造会编译报错)，自定义类型成员在声明时也可以给缺省，如果初始化列表显示调用该成员构造就不用这个缺省。

  • 初始化列表对成员变量的初始化内容可以是变量，常量，表达式，函数调用等。
int fun()
{
	return 1;
}

MyQueue(int n =1)
 :_size(n+1), //表达式 也可以是_size(fun())
  _capacity(1),//常量
  _ptr((int*)malloc(8)) 
{}
  • 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
    次序无关 。 
class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() 
   {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};

int main()
{
    A aa(1);
    aa.Print();
}

A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

本题正确答案为1。

由于声明顺序即初始化列表中初始化顺序，因此会先初始化a2，此时a1还未初始化，a2就被初始化为随机值，a1正常初始化为1.

  • 实践中我们尽可能使用初始化列表初始化，不方便再用函数体初始化。
MyQueue()
 :_size(1),
  _ptr((int*)malloc(40))
{
   memset(_ptr,1,40); //此时适合用函数体
}

对于自定义类型使用初始化列表初始化列表可以提高效率。

class B
{
public:
	B(int ab= 9)
	{
		cout << "B()" << endl;
	}
private:
	int _b = 2; //用缺省值初始化
};


class A
{
public:
	A()
	:_b(2) //初始化列表初始化 
	{}

	A(int a) //不用初始化列表初始化
	{
		B hh;
		_b = hh;
	}
	
private:
	int _a2;
	int _a1;
	B _b;
};

说明：

  1. 用初始化列表对自定义成员进行初始化，此时只会调用一次构造，无论默认构造还是其他构造。
  2. 如果想在函数体内对自定义成员初始化，无论是否显示写，都会先对自定义成员调用默认构造，再在类内调用一次构造和拷贝构造，无疑是降低效率的。

对于内置类型成员，它走不走初始化列表初始化，其初始化和赋值成本相同，但是为了一致性最好也通过初始化列表初始化。

📌explic关键字

📒 隐式类型转换

  • 单参数隐式类型转换
class A
{
public:
 A(int a  = 2)
    :_a(a)
 {}
private: 
  int _a;
};

int main()
{
  A aa1(1);
  //拷贝构造
  A aa2 = aa1;

 //单参数隐式类型转换  内置类型->自定义类型
  A aa3 = 3;
  return 0;
}

对于aa3这个对象，直接将int转化给A类型是转不过去的；它会先用3构造出一个临时对象，再对这个临时对象进行拷贝创建aa3.我们C语言阶段对变量的赋值，比如int d = n + 3，也会产生临时变量储存运算结果。

 由于产生的临时对象具有“常性”，如果要用引用介绍的话需要用const引用。

const A& a1 = 3;

好处：方便和提高代码可读性。

class Stack
{
public:
 void push(const A& aa)
 {
    //...
 }
//...
};

int main()
{
  Stack st;
  //以前是传对象
  A a1(1);
  st.push(a1);
  //现在用隐式类型转换更加清晰且减少代码量
  st.push(3);
}

  • 多参数隐式类型转换
class A
{
public:
   A(int a1,int a2)
    :_a(0),
     _a1(a1),
     _a2(a2)
  {}

private:
   int _a;
   int _a1;
   int _a2;
};

int main()
{
 A aa1(1,2);
 A aa2 = {1,2};
 const A& aa3 = {1,2};
 return 0;
}

说明：

1. 对于aa1调用的其实是单参构造，因为逗号表达式返回的是括号最右边的结果。

2.对于aa2其实是进行了多参数的隐式类型转换，编译器用{1,2}调用了多参构造生成临时对象，再对这个临时对象进行拷贝创建新对象。

3. 对于aa3,由于临时对象具有常性，因此需要用const引用接收。

  • 隐式类型转换与缺省值

我们前面知道缺省值是给初始化列表准备的，我们也可以在自定义类型成员声明时给缺省值，可以对他们进行隐式类型转换或者拷贝。

class B
{

private:
 A _a1 = 1; //单参隐式类型
 A _a2 = {1,2};//多参隐式类型转换
 A _a3 = _a2;//拷贝
};

📒 explicit关键字作用

我们若是想禁止构造函数的隐式转换，可以用关键字explicit来修饰构造函数。

class Date
{
public:
 // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
 explicit Date(int year)
 :_year(year)
 {}

 // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
有类型转换作用
 // explicit修饰构造函数，禁止类型转换
 explicit Date(int year, int month = 1, int day = 1)
   :_year(year)
   ,_month(month)
   ,_day(day)
 {}
 
 Date& operator=(const Date& d)
 {
  if (this != &d)
  {
   _year = d._year;
   _month = d._month;
   _day = d._day;
  }
  return *this;
 }

private:
 int _year;
 int _month;
 int _day;
};


void Test()
{
 Date d1(2022);
 // 用一个整形变量给日期类型对象赋值
 // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
  d1 = 2023;
 // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转
换的作用
}

🏠 static成员

📌static成员变量

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量。
  • 静态成员不存在对象中，存在静态区
class A
{
public:
  A(){++_scount;}
  A(const A& t){ ++_scount;}
  ~A() {--_scount;}
private:
  int _a1;
  int _a2;
  static int _scount; //静态成员
};

int main()
{
  A aa1;
  cout << sizeof(aa1) << endl;
  return 0;
}

输出：8 

结论：对象中只存非静态成员变量，不存静态成员和成员函数。

  • 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。 
class A
{
public:
  A(){++_scount;}
  A(const A& t){ ++_scount;}
  ~A() {--_scount;}
private:
  int _a1;
  int _a2;
  static int _scount; //静态成员
};

int A::_scount = 0; //定义

静态成员变量不能给缺省值，因为缺省值是给走初始化列表的成员准备的，静态成员变量不存在对象中，因此不走初始化列表，也就不能给缺省值。

  • 静态成员也是类的成员，受public、protected、private 访问限定符的限制。
  • 类静态成员即可用 类名::静态成员 或者 对象.静态成员来访问。 
//前提是公有
//对象.静态成员
aa1._scount;
//类名::静态成员
cout << A::_scount << endl;
  • 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
应用： 
//1.可以利用对象共享静态成员变量计数多少个对象被创建
A()
{
  ++_scount;
}

//2.计数有多少对象存活
~A()
{
  --_scount;
}

//3.方便我们查看是否拷贝
A(const A& t)
{
  ++_scount;
}

我们访问静态成员变量前提是它的访问权限是公有，如果它是私有，我们有什么方法对其进行访问呢？此时我们可以利用静态成员函数进行访问。

📌static成员函数

用static修饰的成员函数，称之为静态成员函数。
  • 静态成员函数没有隐藏的this指针，不能访问任何非静态成员，它只能访问静态成员变量 。 
class A
{
public:
	static int GetN()
	{
		return _n;
	}
private:
	static int _n;
};

int A::_n = 0;
int main()
{
	A a;
	cout << a.GetN() << endl; //1.通过对象调用成员函数进行访问
	cout << A().GetN() << endl; //2.通过匿名对象调用成员函数进行访问
	cout << A::GetN() << endl; //3.通过类名调用静态成员函数进行访问
	return 0;
}

注：静态成员函数能直接指定类域调用，是因为它没有this指针，不需要对象传指针。

【问题】

1. 静态成员函数可以调用非静态成员函数吗？

2. 非静态成员函数可以调用类的静态成员函数吗？

1. 不可以。因为非静态成员函数的第一个形参默认为this指针，而静态成员函数中没有this指针，故静态成员函数不可调用非静态成员函数。

2. 可以。因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

  • 构造是特殊的成员函数，静态成员函数也不能调用构造，但能间接调用。
class A
{
public:
  static A func()
 {
   return A();
 }

};

注：这里并不是在静态成员函数里调用非静态成员函数，而是通过定义一个对象间接调用构造，定义对象并不需要this指针。

🏠 友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

📌友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。 
class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d); //友元声明
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
private:
 int _year;
 int _month;
 int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
  • 友元函数可访问类的私有和保护成员，但不是类的成员函数 。
  • 友元函数不能用const修饰。

这是因为友元函数并不是类的成员函数，类的成员函数含有this指针，this指针才需要被const修饰。

  • 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
  • 一个函数可以是多个类的友元函数。
  • 友元函数的调用与普通函数的调用原理相同。

📌友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
  • 友元关系是单向的，不具有交换性。
比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
  • 友元关系不能传递。
如果C是B的友元， B是A的友元，则不能说明C时A的友元。
  • 友元关系不能继承。

🏠 内部类

📌概念

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

📌特性

  • 内部类可以定义在外部类的public、protected、private都是可以的。
  • 内部类和外部类是两个平行的类， 内部类并不是它的成员，内部类是个独立的类， 它仅仅是受到外部类的类域限制。 
class A
{
private:
 static int k;
 int h;
public:
 void fun()
 {}
//内部类
 class B
 {
  public:
   void foo(const A & a)
   { //...}
 private:
    int _b; 
 };

};

int main()
{
  cout << sizeof(A) << endl;
  A::B b1;
}

由于内部类是独立的所以sizeof(外部类)和内部类没有任何关系，由于内部类声明在外部类，因此创建内部类对象时，需要指明外部类的类域。

  • 内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
  • 内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

🏠 匿名对象

📌 特点

  • 匿名对象不需要对象名，且生命周期很短，创建完即销毁。
class Test
{
public:
 ~Test()
{
  cout << "~Test()" << endl;
}

Test()
{
 cout << "Test()" << endl;
}


};

int main()
{
 Test();
 cout << "111111111" <<endl;
}

📌 好处

void f1(const A& aa)
{}

int main()
{
//传值传参
 A aa1;
 f1(aa1);
//匿名对象
f1(A());
}
在这种场景下使用匿名对象就方便不少。
注：匿名对象也具有类似临时对象的"常性"，也需要用const引用接收。

🏠 拷贝里的编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。
  • 一个表达式中，连续构造+拷贝构造->优化为一个构造。(多个式子则不会优化) 
class Test
{
public:
	Test(int t = 10)
		:_t(t)
	{
		cout << "Test()" << endl;
	}
	Test(const Test& t)
	{
		cout << "Test(const Test& t)" << endl;
	} 

	~Test()
	{
		cout << "~Test()" << endl;
	}

private:
	int _t;
};

void f1(Test t)
{}

int main()
{
	Test t1;
	f1(t1);
	cout << endl;

	f1(Test(2));
	cout << endl;

	f1(2);
	cout << "111111111" << endl;
}

输出结果：

//不是一个连续表达式 不优化

Test()
Test(const Test& t)
~Test()

 //优化

Test()
~Test()

//优化

Test()
~Test()
111111111
~Test() //t1析构

  • 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 
A f2()
{
  A aa;
  return aa;
}

int main()
{
 A ret1 = f2();
 const A& ret2 f2();
}

注：对于ret1是一个表达式中进行连续的拷贝构造+拷贝构造会进行优化，而ret1由于是传引用传参所以不会优化。

  • 一个表达式中，连续拷贝构造+赋值重载->无法优化 
A f2()
{
  A aa;
  return aa;
}

int main()
{
  A ret;
  ret2  = f2();
  cout << endl;
  return 0;
}

此时是连续的拷贝构造+拷贝赋值重载，两者不是一个性质，所以无法进行优化。

🏠 再次理解类和对象

类是对某一类实体 ( 对象 ) 来进行描述的，描述该对象具有那 些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化 具体的对象 。

本节我们更深刻关于构造函数对成员的初始化机理，以及学习了特殊的stactic成员，内部类，匿名对象和友元技术，通过这些我们更能理解类和对象之间的关系。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2067659.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【图形学】TA之路-基于Unity Shader编程之初体验

【图形学】TA之路-基于Unity Shader编程之初体验

学习shader之前你必须知道的事情&#xff1a; Unity开发引擎、Direct3D、Shader他们之间的关系 Direct3D 是一个底层图形 API&#xff0c;它直接与 GPU &#xff08;显卡&#xff09;交互&#xff0c;提供了访问硬件加速功能的接口。Unity 开发引擎&#xff0c;它封装了很多底…
阅读更多...
[Linux] 认识系统服务（daemon）

[Linux] 认识系统服务（daemon）

参考&#xff1a;《鸟哥的Linux私房菜》 一、什么是 daemon 与服务&#xff08;service&#xff09; 在英语中的daemon就有守护进程&#xff0c;后台程序的意思。简单来说就是一直在后台运行的进程&#xff0c;我们就称之为服务(service)&#xff0c;或者是守护进程(daemon)。…
阅读更多...
Java爬虫图像处理：从获取到解析

Java爬虫图像处理：从获取到解析

在互联网时代&#xff0c;数据的价值日益凸显&#xff0c;而爬虫技术作为获取网络数据的重要手段&#xff0c;其应用范围越来越广泛。本文将探讨Java爬虫在图像处理方面的应用&#xff0c;包括如何从网络中获取图像数据&#xff0c;以及如何对这些数据进行解析和处理。 Java爬…
阅读更多...
实现Kruskal算法连通游戏地图地牢

实现Kruskal算法连通游戏地图地牢

前置知识 c分享&#xff5c;并查集从入门到出门 - 力扣&#xff08;LeetCode&#xff09; 彻底搞懂克鲁斯卡尔&#xff08;Kruskal&#xff09;算法&#xff08;附C代码实现&#xff09; - QuanHa - 博客园 (cnblogs.com) 白色点矩形是地牢&#xff0c;其中白线是按照krsukal…
阅读更多...
网络编程知识点总结

网络编程知识点总结

物理链路网络运输会话表示应用 物链网运会表应 实际的数据帧 TCP和UDP的异同&#xff08;笔试面试&#xff09; 主机&#xff1a;host 转换&#xff1a;to 网络&#xff1a;network uint32_t htonl(uint32_t hostlong); //将4字节无符号整数的主机字节序转换为网络字节序&a…
阅读更多...
云计算实训32——roles基本用法、使用剧本安装nginx、使用roles实现lnmp

云计算实训32——roles基本用法、使用剧本安装nginx、使用roles实现lnmp

一、安装nginx并更改其端口 编辑hosts配置文件 [rootmo ~]# vim /etc/ansible/hosts 创建目录 [rootmo ~]# mkdir /etc/ansible/playbook 编辑配置文件 [rootmo ~]# vim /etc/ansible/playbook/nginx.yml 执行测试 [rootmo ~]# ansible-playbook /etc/ansible/playbook/n…
阅读更多...
菜鸟的进击之.net6控制台应用程序接收参数

菜鸟的进击之.net6控制台应用程序接收参数

1、新建控制台应用程序&#xff0c;新建-添加项目-控制台应用 2、3、下一步&#xff0c;填写项目名称和代码存放的位置 3、下一步&#xff0c;框架选择.net 6 &#xff0c;点击创建 4、然后项目就创建完成啦&#xff0c; 5、在可以直接在Program.cs写方法一些简单的逻辑&#x…
阅读更多...
Rustrover、IDEA 的 Rust 类型不显示（已解决）

Rustrover、IDEA 的 Rust 类型不显示（已解决）

关键词&#xff1a;rustrover 类型不显示&#xff0c;rustrover 不显示类型&#xff0c;IntelliJ IDEA Rust 类型不显示&#xff0c;IntelliJ IDEA Rust 不显示类型 若移动端访问不佳&#xff0c;请使用 –> Github版 背景 博主手欠&#xff0c;使用 IntelliJ IDEA 时&am…
阅读更多...
四款流行英文翻译工具，助你轻松应对翻译难题

四款流行英文翻译工具，助你轻松应对翻译难题

作为一名教培行业的工作人员&#xff0c;我经常需要处理大量的英文文件&#xff0c;从教材到学术论文&#xff0c;再到各种国际交流的资料。翻译工具成了我工作中不可或缺的帮手。今天&#xff0c;我就来跟大家聊聊我用过的几款翻译工具在翻译英文文件时的表现如何呢&#xff1…
阅读更多...
超越IP-Adapter！阿里提出UniPortrait，可通过文本定制生成高保真的单人或多人图像。

超越IP-Adapter！阿里提出UniPortrait，可通过文本定制生成高保真的单人或多人图像。

阿里提出UniPortrait&#xff0c;能根据用户提供的文本描述&#xff0c;快速生成既忠实于原图又能灵活调整的个性化人像&#xff0c;用户甚至可以通过简单的句子来描述多个不同的人物&#xff0c;而不需要一一指定每个人的位置。这种设计大大简化了用户的操作&#xff0c;提升了…
阅读更多...
手机游玩植物大战僵尸杂交版V2.3.7最新版教程（文章末尾免费直接下载链接）

手机游玩植物大战僵尸杂交版V2.3.7最新版教程（文章末尾免费直接下载链接）

手机游玩植物大战僵尸杂交版V2.3.7最新版教程 【V2.3.7全面升级】植物大战僵尸杂交版&#xff1a;跨平台终极安装指南 - 苹果、安卓、电脑、电视兼容&#xff0c;界面革新&#xff0c;16卡槽扩展&#xff0c;高分辨率支持&#xff0c;BUG修复&#xff0c;畅享游戏乐趣 前言 …
阅读更多...
市盈率的概念

市盈率的概念

写篇有关市盈率的【不务正业】的内容。 重要公式 市盈率 官方的定义 平均市盈率&#xff1d;∑(收盘价发行数量)/∑(每股收益发行数量)&#xff0c;统计时剔除亏损及暂停上市的上市公司。 静态市盈率 滚动市盈率&#xff08;TTM&#xff09; 股票市盈率的意义 如果某股票有较…
阅读更多...
探索数据结构：图(二)之图的遍历，Kruskal与Prim算法

探索数据结构：图(二)之图的遍历，Kruskal与Prim算法

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ &#x1f388;&#x1f388;养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; 所属专栏&#xff1a;数据结构与算法 贝蒂的主页&#xff1a;Betty’s blog 1. 图的遍历 图的遍历方式一般分为两种&#xff1a;深度优先遍历与广度…
阅读更多...
gurobi中引入松弛变量和剩余变量的用法

gurobi中引入松弛变量和剩余变量的用法

文章目录 1. 松弛变量&#xff1a;用于“≤”不等式约束数学表达式 2. 剩余变量&#xff1a;用于“≥”不等式约束数学表达式 3. 目标函数中的松弛变量数学表达式 4. Gurobi中的实现对于“≤”不等式的松弛变量&#xff1a;对于“≥”不等式的剩余变量&#xff1a; 5. 总结 在G…
阅读更多...
p2p、分布式，区块链笔记: IPFS库Helia的文件系统Unix File System (UnixFS)

p2p、分布式，区块链笔记: IPFS库Helia的文件系统Unix File System (UnixFS)

Unix File System (UnixFS) Helia中定义一个UnixFS类用于文件处理。The Unix File System (UnixFS) is the data format used to represent files and all their links and metadata in IPFS.。UnixFS中的方法封装了常见的文件系统操作&#xff0c;使得在去中心化文件系统中处…
阅读更多...
跨越时代的Zynq PL编程：从xdevcfg到FPGA Manager的进化

跨越时代的Zynq PL编程：从xdevcfg到FPGA Manager的进化

引言 在嵌入式系统设计与开发的广阔领域中&#xff0c;Xilinx Zynq平台以其独特的ARM处理器与FPGA可编程逻辑&#xff08;PL&#xff09;的结合&#xff0c;成为了众多创新项目的首选。然而&#xff0c;随着技术的不断进步&#xff0c;Zynq PL的编程方式也经历了从经典到现代的…
阅读更多...
【UCB CS61C】Lecture 2 3 - C Basics

【UCB CS61C】Lecture 2 3 - C Basics

目录 C 语言的编译&#xff08;Compilation&#xff09;变量类型&#xff08;Variable Types&#xff09;字符&#xff08;Characters&#xff09; C 语言的类型转换&#xff08;Typecasting&#xff09;类型函数&#xff08;Typed Functions&#xff09; 结构体&#xff08;St…
阅读更多...
【C++ Primer Plus习题】3.6

【C++ Primer Plus习题】3.6

问题: 解答: #include <iostream> using namespace std;int main() {float miles 0;float gallons 0;float gallon 0;cout << "请输入驱车里程(单位为英里):";cin >> miles;cout << "请输入使用的汽油量(单位为加仑):";cin &g…
阅读更多...
【数据结构】一篇讲清楚什么是堆? 带图食用超详细~

【数据结构】一篇讲清楚什么是堆? 带图食用超详细~

目录 一、堆的概念 1.堆是一个完全二叉树 2.堆分为大根堆和小根堆。 3.堆与优先级队列的关系 二、堆操作 1.向下调整 2.删除堆顶元素 3.添加新元素 4.构建堆 A&#xff1a;自底向上构建 B&#xff1a;自顶向下构建 C&#xff1a;两种方式对比 三、尝试自己编程实现堆…
阅读更多...
redis实战——go-redis的使用与redis基础数据类型的使用场景(二)

redis实战——go-redis的使用与redis基础数据类型的使用场景(二)

一.go-redis操作hash 常用命令&#xff1a; redisClient.HSet("map", "name", "jack") // 批量设置 redisClient.HMSet("map", map[string]interface{}{"a": "b", "c": "d", "e"…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023