C++ IOStream

news2024/11/15 1:10:25
  • IOStream
    • 类流特性
      • 不可赋值和复制
      • 缓冲
      • 重载了<< >>
  • 状态位
    • 示例
  • 状态位操作函数
  • cout
  • cin
    • get
    • get(s,n)/get(s,n,d):
    • getline
  • other
  • if(!fs)/while(cin)
    • operator void*()与 operator!()
    • 代码示例
  • File Stream
    • open 函数
      • 文件打开方式
  • 文件读写
    • 读写接口
      • 一次读一个字符
      • 一次读一行
      • 读写二进制
  • 文件指针相关的函数

IOStream

在这里插入图片描述

类流特性

不可赋值和复制

#include <iostream>
#include <fstream>
using namespace std;
void print(fstream fs) //fstream& fs
{
}
int main()
{
    fstream fs1,fs2;
    fs1 = fs2;
    fstream fs3(fs2);
    print(fs3);
  return 0;
}

不同于标准库其他 class 的"值语意"，iostream 是"对象语意"，即 iostream
是 non-copyable。这是正确的，因为如果 fstream 代表一个文件的话，拷贝一个
fstream 对象意味着什么呢？表示打开了两个文件吗？如果销毁一个 fstream 对象，它会关闭文件句柄，那么另一个 fstream copy 对象会因此受影响吗？

C++ 同时支持"数据抽象"和"面向对象编程"，其实主要就是"值语意"与"对象语意
"的区别，标准库里的 complex<> 、pair<>、vector<>、 string 等等都是值语意，
拷贝之后就与原对象脱离关系，就跟拷贝一个 int 一样。而我们自己写的 Employee
class、TcpConnection class 通常是对象语意，拷贝一个 Employee 对象是没有
意义的，一个雇员不会变成两个雇员，他也不会领两份薪水。拷贝 TcpConnection 对
象也没有意义，系统里边只有一个 TCP 连接，拷贝 TcpConnection 对象不会让我们
拥有两个连接。因此如果在 C++ 里做面向对象编程，写的 class 通常应该禁用 copy
constructor 和 assignment operator。

缓冲

下面几种情况会导致刷缓冲
1，程序正常结束，作为 main 函数结束的一部分，将清空所有缓冲区。
2，缓冲区满，则会刷缓冲。
3，endl, flush 也会刷缓冲。

重载了<< >>

#include <iostream>  // 引入标准输入输出流库
#include <fstream>    // 引入文件流库
using namespace std;  // 使用标准命名空间

int main()
{
    // 创建一个 fstream 对象 fs，打开名为 "abc.txt" 的文件，模式为输入、输出和截断（清空文件内容）
    fstream fs("abc.txt", ios::in | ios::out | ios::trunc);

    // 检查文件是否成功打开
    if (!fs)
    {
        // 如果文件打开失败，输出错误信息
        cout << "error" << endl;
    }

    // 向文件中写入数据 "1 2 3"
    fs << 1 << " " << 2 << " " << 3;

    // 将文件指针重新定位到文件开头
    fs.seekg(0, ios::beg);

    // 声明三个整数变量 x, y, z
    int x, y, z;

    // 从文件中读取数据到变量 x, y, z
    fs >> x >> y >> z;

    // 输出读取到的数据
    cout << x << y << z;

    // 程序结束，返回 0 表示成功
    return 0;
}

状态位

大部分情况下 ， 我们可能并不关心这些标志状态位 ， 比如我们以前用到的 cin/cout。
但是在循环读写中，这些标志位确实大用用途。比如，用于判断文件结束
标志的位。

ios_base.h 中状态位的定义如下：

/// Indicates a loss of integrity in an input or output sequence (such
/// as an irrecoverable read error from a file).
static const iostate badbit = _S_badbit;
/// Indicates that an input operation reached the end of an input sequence.
static const iostate eofbit = _S_eofbit;
/// Indicates that an input operation failed to read the expected
/// characters, or that an output operation failed to generate the
/// desired characters.
static const iostate failbit = _S_failbit;
/// Indicates all is well.
static const iostate goodbit = _S_goodbit;

在C++标准库中，ios_base.h头文件定义了输入输出流的基础类ios_base，以及与之相关的各种枚举和常量。
其中，状态位（state flags）用于表示流的状态。
这些状态位可以通过ios_base类的成员函数进行设置和查询。

以下是一些常用的状态位：

goodbit：表示流处于正常状态，没有错误。
badbit：表示流发生了致命错误，可能导致数据丢失。
failbit：表示流发生了可恢复的错误，通常是由于格式错误或无效输入。
eofbit：表示流已经到达文件末尾。

这些状态位可以通过ios_base类的以下成员函数进行操作：

rdstate()：返回当前的状态位。
setstate(iostate state)：设置指定的状态位。
clear(iostate state = goodbit)：清除当前的状态位，并设置为指定的状态位。

示例

在这个例子中，我们打开一个文件并检查其状态。
如果文件无法打开，程序会输出错误信息并退出。
然后，我们尝试从文件中读取数据，
并检查读取操作后的状态位，以确定是否成功读取数据或是否到达文件末尾。

#include <iostream>
#include <fstream>

int main() {
    std::ifstream file("example.txt");
    if (!file) {
        std::cerr << "无法打开文件" << std::endl;
        return 1;
    }

    // 检查流的状态
    if (file.rdstate() & std::ios_base::failbit) {
        std::cerr << "流发生了可恢复的错误" << std::endl;
    }

    // 读取文件内容
    int data;
    file >> data;

    // 检查读取操作后的状态
    if (file.rdstate() & std::ios_base::eofbit) {
        std::cout << "已到达文件末尾" << std::endl;
    }
    if (file.rdstate() & std::ios_base::failbit) {
        std::cerr << "读取操作失败" << std::endl;
    }

    file.close();
    return 0;
}

状态位操作函数

函数功能
eof()如果读文件到达文件末尾，返回 true。
fail()除了与 bad() 同样的情况下会返回 true 以外，加上格式错误时也返回 true ， 例如当想要读入一个整数，而获得了一个字母的时候。或是遇到 eof。
bad()如果在读写过程中出错，返回 true 。例如：当我们要对一个不是打开为写状态的文件进行写入时，或者我们要写入的设备没有剩余空间的时候。
clear()标识位一旦被置位，这些标志将不会被改变，要想重置以上成员函数所检查的状态标志，你可以使用成员函数 clear()，没有参数。比如:通过函数移动文件指针，并不会使 eofbit 自动重置。
good()这是最通用的：如果调用以上任何一个函数返回 true 的话，此函数返回 false 。
在这段代码中，主要使用了以下几个与输入流状态相关的函数：

cin.eof():

功能：检查是否到达文件末尾（EOF）。
返回值：如果到达文件末尾，返回true；否则返回false。
使用场景：通常在读取文件时使用，用于判断是否已经读取到文件的末尾。

cin.fail():

功能：检查是否发生格式错误。例如，尝试将非数字字符读取为整数时会触发格式错误。
返回值：如果发生格式错误，返回true；否则返回false。
使用场景：用于检测输入操作是否因为格式不匹配而失败。

cin.bad():

功能：检查是否发生致命错误。例如，流被破坏或硬件故障等。
返回值：如果发生致命错误，返回true；否则返回false。
使用场景：用于检测流是否处于不可恢复的错误状态。

cin.good():

功能：检查流是否处于良好状态，即没有发生任何错误。
返回值：如果流处于良好状态，返回true；否则返回false。
使用场景：用于检测流是否可以正常使用。

cin.clear():

功能：清除流的错误状态标志。调用此函数后，流的failbit和badbit会被清除，流的状态会被重置为良好状态。
参数：可以传递一个参数来指定要清除的错误标志，默认情况下会清除所有错误标志。
使用场景：在检测到输入错误后，通常需要调用此函数来清除错误状态，以便继续使用流进行后续的输入操作。

通过这些函数，程序可以有效地检测和处理输入流中的错误，确保输入操作的可靠性和程序的健壮性。
在实际应用中，这些函数常用于输入验证和错误处理，以提高程序的容错能力。


#include <iostream>
using namespace std;

int main()
{
    int val;

    // 输出在错误输入操作之前的流状态
    cout << "Before a bad input operation:"
         << "\n cin.eof() : " << cin.eof()  // 检查是否到达文件末尾
         << "\n cin.fail(): " << cin.fail() // 检查是否发生格式错误
         << "\n cin.bad() : " << cin.bad()  // 检查是否发生致命错误
         << "\n cin.good(): " << cin.good() // 检查流是否处于良好状态
         << endl;

    // 尝试从标准输入读取一个整数，可以通过输入非数字字符（如'a'）或模拟文件结束（如在Unix系统上按Ctrl+D，在Windows系统上按Ctrl+Z）来触发错误
    cin >> val;

    // 输出在错误输入操作之后的流状态
    cout << "After a bad input operation:"
         << "\n cin.eof() : " << cin.eof()  // 检查是否到达文件末尾
         << "\n cin.fail(): " << cin.fail() // 检查是否发生格式错误
         << "\n cin.bad() : " << cin.bad()  // 检查是否发生致命错误
         << "\n cin.good(): " << cin.good() // 检查流是否处于良好状态
         << endl;

    // 清除流的错误状态标志
    cin.clear();

    // 输出清除错误状态标志后的流状态
    cout << "\n cin.eof() : " << cin.eof()  // 检查是否到达文件末尾
         << "\n cin.fail(): " << cin.fail() // 检查是否发生格式错误
         << "\n cin.bad() : " << cin.bad()  // 检查是否发生致命错误
         << "\n cin.good(): " << cin.good() // 检查流是否处于良好状态
         << endl;

    return 0;
}

cout

格式输出:

在这里插入图片描述

成员函数:

函数功能
ostream& put( char )输出一个字符
ostream& write( const char* s, streamsize n )输出一个字符串
ostream& operator<<(T v)输出一个值

cin

get

函数声明
int get();
istream& get (char& c);
istream& get (char* s, streamsize n);          //终止符为'\n'
istream& get (char* s, streamsize n, char delim);


#include <iostream>
using namespace std;
int main()
{
    char ch;
    while((ch = cin.get())!=EOF)
    {
        cout<<ch<<endl;
    }
    while(cin.get(ch))
    {
        cout<<ch<<endl;
    }
    return 0;
}

get(s,n)/get(s,n,d):

#include <iostream>
using namespace std;
int main()
{
    char ch;
    char buf[10];
    while(cin.get(buf,10))
    {
        cout<<buf<<endl;
    }
    cout<< "\n cin.eof() : " <<cin.eof()
        << "\n cin.fail(): " <<cin.fail()
        << "\n cin.bad() : " <<cin.bad()
        << "\n cin.good(): " <<cin.good()<<endl;
    return 0;
}

输出:
12345678901234567890
123456789
012345678
90

 cin.eof() : 0
 cin.fail(): 1
 cin.bad() : 0
 cin.good(): 0


#include <iostream>
using namespace std;
int main()
{
    char ch;
    char buf[10];
    while(cin.get(buf,10,'S'))
    {
        cout<<buf<<endl;
    }
    cout<< "\n cin.eof() : " <<cin.eof()
        << "\n cin.fail(): " <<cin.fail()
        << "\n cin.bad() : " <<cin.bad()
        << "\n cin.good(): " <<cin.good()<<endl;
    return 0;
}

输出:
cvdScjkvds
cvd

 cin.eof() : 0
 cin.fail(): 1
 cin.bad() : 0
 cin.good(): 0

getline

函数声明
istream& getline (char* s, streamsize n );
istream& getline (char* s, streamsize n, char delim );

在读取 n-1 个字符前，遇到标志位，则会读到标志位前的字符。然后越过标志位
继续读取。
若在读到 n-1 个字符前没有遇到标志位，则会退出。

#include <iostream>
using namespace std;
int main()
{
    char buf[10];
    while(cin.getline(buf,10))
    {
        cout<<buf<<endl;
    }
    cout<< "\ncin.eof() : " <<cin.eof()
        << "\ncin.fail(): " <<cin.fail()
        << "\ncin.bad() : " <<cin.bad()
        << "\ncin.good(): " <<cin.good()<<endl;
    return 0;
}

输出
1234567890

cin.eof() : 0
cin.fail(): 1
cin.bad() : 0
cin.good(): 0


输出
123456789
123456789

ad fd gd
ad fd gd

#include <iostream>
using namespace std;
int main()
{
    char buf[10];
    while(cin.getline(buf,10,'x'))
    {
        cout<<buf<<endl;
    }
    cout<< "\ncin.eof() : " <<cin.eof()
        << "\ncin.fail(): " <<cin.fail()
        << "\ncin.bad() : " <<cin.bad()
        << "\ncin.good(): " <<cin.good()<<endl;
    return 0;
}

输出
12x22x23x
12
22
23

other

函数声明

 istream& ignore (streamsize n = 1, int delim = EOF);
跳过流中的 n 个字符，或遇到终止字符为止（包含）,默认参数忽略一个字符。

 int peek();
窥视当前指针,文件指针未发生移动

 istream& putback (char c);
回推插入当前指针位置

#include <iostream>
using namespace std;

int main()
{
    char ch[20];

    // 使用cin.get读取输入，最多读取19个字符，直到遇到'/'为止
    // 例如输入 "i like c/ i like C++ also/"，将读取 "i like c"
    cin.get(ch, 20, '/');
    cout << "the first part is :" << ch << endl;

    // 忽略接下来的10个字符或直到遇到字符'i'为止
    cin.ignore(10, 'i');

    // 将字符'i'放回输入流的最前面
    cin.putback('i');

    // 查看输入流中的下一个字符，但不移除它
    // 由于之前putback('i')，所以peek将是'i'
    char peek = cin.peek();
    cout << "peek is :" << peek << endl;

    // 再次使用cin.get读取输入，最多读取19个字符，直到遇到'/'为止
    cin.get(ch, 20, '/');
    cout << "this second part is:" << ch << endl;

    return 0;
}


输出
i like c/ i like C++ also/
the first part is :i like c
peek is :i
this second part is:i like C++ also

if(!fs)/while(cin)

在判断文件打开成功与否或是连续从流中读取数据时，就要用到对流对像的操作，

比如 if(!fs)和 while(cin>>val)，

我们都知道 cin 是一个流对象，
而>>运算符返回左边的流对象，也就是说 cin>>val 返回 cin，

于是 while(cin>>val)就变成了while(cin)，问题就变成了一个流对象在判断语句中的合法性。

不管是 while(cin)还是 if(!fs)，都是合法的，为什么呢？

我们自己定义一个类，然后定义该类的对象，然后使用 if 语句来判断它是不合法
的。

这说明，流对象具有某种转换函数，可以将一个流对象转换成判断语句可以识别的类型。

operator void*()与 operator!()

打开 iostream.h 文件，找到 cin 的定义，发现是来自于 istream.h，其中的模
板类 basic_istream 继承自 basic_ios，打开 basic_ios 的定义,发现它有两个重载
函数。

operator void *() const 和 operator!() const。这两个函数使得流对象
可作为判断语句的内容。

operator void*() const //转化函数 A 类对象-> void *对象
{
return this->fail() ? 0 : const_cast<basic_ios*>(this);
}
bool operator!() const //运算符重载函数 对象调用 operator!()
{
return this->fail();
}

常见策略
while(cin)  ===> while(!cin.fail())   //while the stream is OK
if(!cin)    ===> if(cin.fail())        //if the stream is NOT OK

代码示例


#if 1
#include <iostream>
using namespace std;

class A
{
public:
    A() {}  // 构造函数
    ~A() {} // 析构函数

    // 类型转换运算符，将对象转换为void*类型
    operator void* () const
    {
        cout << "operator void* () cast to void*; " << endl;
        return (void *)this;  // 返回当前对象的指针
    }

    // 重载逻辑非运算符
    bool operator!() const
    {
        cout << "bool operator!() return bool; " << endl;
        return true;  // 返回true
    }
};

int main()
{
    A a;  // 创建对象a

    // 使用对象a作为while循环的条件
    // 由于a可以隐式转换为void*类型，且void*类型的非零值被视为true
    while (a) {
        cout << "while" << endl;
        break;  // 跳出循环
    }

    // 使用对象a作为if语句的条件
    // 由于a可以隐式转换为void*类型，且void*类型的非零值被视为true
    if (a) cout << "first" << endl;

    // 使用逻辑非运算符!a作为if语句的条件
    // 由于重载了!运算符，返回true
    if (!a) cout << "second" << endl;

    return 0;
}

# endif

输出
operator void* () cast to void*;
while
operator void* () cast to void*;
first
bool operator!() return bool;
second

File Stream

对文件的操作是由文件流类完成的。文件流类在流与文件间建立连接。由于文件流
分为三种：文件输入流、文件输出流、文件输入/输出流，所以相应的必须将文件流说
明为 ifstream、ofstream 和 fstream 类的对象，然后利用文件流的对象对文件进行操作

对文件的操作过程可按照以下四步进行：即定义文件流类的对象、打开文件、对文
件进行读写操作、关闭文件，下面分别进行介绍。

流对象的定义

//流类 流对象;
ifstream ifile; //定义一个文件输入流对象
ofstream ofile; //定义一个文件输出流对象
fstream iofile; //定义一个文件输出/输入流对象

open 函数

定义了文件流对象后，就可以利用其成员函数 open（）打开需要操作的文件，该
成员函数的函数原型为：

void open（const unsigned char *filename,int mode,int access=filebuf:openprot);

其中：filename 是一个字符型指针，指定了要打开的文件名；
mode 指定了文件的打开方式，其值如下表所示；
access 指定了文件的系统属性，取默认即可

文件打开方式

打开方式值含义
ios::in0x01以输入（读）方式打开文件，若文件不存在则报错。
ios::out0x02以输出（写）方式打开文件, 若文件不存则创建。
ios::ate0x04打开文件时指针指向文件尾
ios::app0x08打开一个文件使新的内容始终添加在文件的末尾，若文件不存在，则创建。
ios::trunc0x10若文件存在，则截断文件
ios::binary0x80以二进制方式打开文件，缺省时以文本方式打开文件。
ios::nocreate0x20若文件不存在，则打开失败，而不是创建文件。
ios::noreplace0x40若文件存在，则打开失败，而不是覆盖文件。
几点说明：

a.在实际使用过程中，可以根据需要将以上打开文件的方式用"|"组合起来。如：
ios::in|ios::out
表示以读/写方式打开文件

ios::in|ios:: binary
表示以二进制读方式打开文件

ios::out|ios:: binary
表示以二进制写方式打开文件

ios::in|ios::out|ios::binary 表示以二进制读/写方式打开文件



b.如果未指明以二进制方式打开文件，则默认是以文本方式打开文件。

c.构造函数打开文件

对于 ifstream 流， mode 参数的默认值为 ios::in，
对于 ofstream 流，mode 的默 认值为 ios::out|ios::trunc,
对于 fstream 流， mode 的默认值为 ios::int|ios::out|ios::app

d.ios::int|ios::out 是是命名空间的 ios 中一堆枚举

文件读写

读写接口

在这里插入图片描述

一次读一个字符

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    // 创建一个 fstream 对象 fs
    fstream fs;

    // 以读写模式打开文件 "test.txt"，如果文件存在则截断文件
    fs.open("test.txt", ios::in | ios::out | ios::trunc);

    // 检查文件是否成功打开
    if (!fs)
    {
        cout << "open error" << endl;
        return -1; // 如果打开失败，返回 -1
    }

    // 向文件中写入从 'a' 到 'z' 的字符
    for (char c = 'a'; c <= 'z'; c++)
    {
        fs.put(c); // 将字符 c 写入文件
    }

    // 将文件指针移动到文件开头
    fs.seekp(0, ios::beg);

    // 从文件中读取字符并输出到控制台
    char ch;
    while (fs.get(ch)) // 从文件中读取一个字符并存储到 ch 中
    {
        cout << ch << endl; // 输出字符 ch 并换行
    }

    // 关闭文件
    fs.close();

    // 程序正常结束，返回 0
    return 0;
}

可以用<<和>>

 for(char c='a';c<='z';c++){
        fs<<c;
    }
    fs.seekp(0,ios::beg);

    char ch;
    while (fs>>ch){
        cout<<ch<<endl;
    }

一次读一行


#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    fstream fs;
    fs.open("test.txt",ios::in|ios::out|ios::trunc);
    if(!fs)
    {
        cout<<"open error"<<endl;
        return -1;
    }


    //按行写入
    fs<<"hello world1"<<endl;
    fs<<"hello world2"<<endl;
    fs<<"hello world3"<<endl;

    fs.seekp(0,ios::beg);


    char buf[100];
    while (fs>>buf){ //读取一行 以空格换行符为分隔
        cout<<buf<<endl;
    }
    

    //getline读到换行符为止,但是会丢弃换行符,所以要补上换行符
    while (fs.getline(buf,100,'\n')){//'\n'参数不加也是可以的,默认就是换行符
            cout<<buf<<endl;//补上换行符
    }

    
    fs.close();
    return 0;
}

读写二进制

读写接口:

ostream & write(const char*buf, int len);

istream & read(char * buff, int len);

#include <iostream>
#include <fstream>
using namespace std;

// 定义学生结构体
struct Student
{
    char name[100]; // 学生姓名
    int num;        // 学生学号
    int age;        // 学生年龄
    char sex;       // 学生性别
};

int main() {
    fstream fs; // 定义文件流对象

    // 打开文件，模式为读写和截断（如果文件存在，清空文件内容）
    fs.open("test.txt", ios::in | ios::out | ios::trunc);

    // 检查文件是否成功打开
    if (!fs) {
        cout << "open error" << endl;
        return -1; // 打开失败，返回错误码
    }

    // 定义并初始化学生数组
    Student s[3] = {
            {"li",   1001, 18, 'f'},
            {"liu",  1002, 19, 'm'},
            {"Wang", 1004, 17, 'f'}
    };

    // 将学生数组以二进制形式写入文件
    fs.write((char*)&s, sizeof(s));

    // 将文件指针移动到文件开头
    fs.seekp(0, ios::beg);

    Student s1; // 定义一个学生结构体变量用于读取数据

    // 从文件中读取数据，直到文件结束
    while (fs.read((char*)&s1, sizeof(s1))){
        // 输出读取到的学生信息
        cout << s1.name << " " << s1.num << " " << s1.age << " " << s1.sex << endl;
    }

    fs.close(); // 关闭文件
    return 0; // 程序正常结束
}


输出
li 1001 18 f
liu 1002 19 m
Wang 1004 17 f

文件指针相关的函数

在这里插入图片描述

g 代表 get 的意思用于输入的函数。p 代表 put 的意思，用于输出函数。如果既是
可输入又是可输出的文件，则任意使用。

在这里插入图片描述

代码示例：

infile.seekg(100);//输入文件中的指针向前移到 100 个字节的位置
infile.seekg(-50,ios::cur); //输入文件中的指针从当前位置后移 50 个字节
outfile.seekp(-75,iso::end); //输出文件中指针从文件尾后移 75 个字节

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

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

相关文章

SpringBoot学习之EasyExcel解析合并单元格（三十九）

SpringBoot学习之EasyExcel解析合并单元格（三十九）

本解析主要采用反射来修改EasyExcel 返回的默认数据结构实现。 一、待解析表格 二、依赖 全部pom.xml文件如下，仅作参考： <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLo…
阅读更多...
LLM - 使用 HuggingFace + Ollama 部署最新大模型 (GGUF 格式 与 Llama 3.1)

LLM - 使用 HuggingFace + Ollama 部署最新大模型 (GGUF 格式 与 Llama 3.1)

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/141028040 免责声明&#xff1a;本文来源于个人知识与公开资料&#xff0c;仅用于学术交流&#xff0c;欢迎讨论&#xff0c;不支持转载。 Ollama…
阅读更多...
创建一个自己的列表窗口

创建一个自己的列表窗口

文章目录 背景&#xff1a;在QT的设计中&#xff0c;对于控件库提供的控件满足不了项目的需求&#xff0c;就像自定义一些控件&#xff0c;本文是自定义一个列表窗口。效果展示 一、创建基本的QT模板&#xff1a;1.创建mainwindow2.创建VerticalTextDelegate 二&#xff1a; 插…
阅读更多...
零拷贝的发展历程

零拷贝的发展历程

零拷贝 零拷贝是指计算机执行 IO 操作时&#xff0c;CPU 不需要将数据从一个存储区域复制到另一个存储区域&#xff0c;从而可以减少上下文切换以及 CPU的拷贝时间。它是一种I/O 操作优化技术。 传统IO的执行流程&#xff1a;传统的 IO 流程&#xff0c;包括 read 读 和 write…
阅读更多...
2024.8.08（python）

2024.8.08（python）

一、搭建python环境 1、检查是否安装python [rootpython ~]# yum list installed | grep python [rootpython ~]# yum list | grep python3 2、安装python3 [rootpython ~]# yum -y install python3 安装3.12可以使用源码安装 3、查看版本信息 [rootpython ~]# python3 --vers…
阅读更多...
C++（类和对象.下）

C++（类和对象.下）

类型转换 先给出以下代码&#xff1a; #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; class B { private:int _a1; public:B(int a){_a1 a;}void Print() {cout << _a1<< endl;} }; int main() {//实例化对象1B b(1);b.Pri…
阅读更多...
video-retalking部署安装，在服务器Ubuntu22.04系统下

video-retalking部署安装，在服务器Ubuntu22.04系统下

video-retalking部署安装&#xff0c;在服务器Ubuntu22.04系统下 一、ubuntu基本环境配置1.更新包列表&#xff1a;2. 安装英伟达显卡驱动2.1 使用wget在命令行下载驱动包2.2 更新软件列表和安装必要软件、依赖2.2 卸载原有驱动2.3 安装驱动2.4 安装CUDA2.5 环境变量配置 二、安…
阅读更多...
基于YOLOv10深度学习的交通信号灯检测识别系统【python源码+Pyqt5界面+数据集+训练代码】红绿灯检测、目标检测、人工智能

基于YOLOv10深度学习的交通信号灯检测识别系统【python源码+Pyqt5界面+数据集+训练代码】红绿灯检测、目标检测、人工智能

《博主简介》 小伙伴们好&#xff0c;我是阿旭。专注于人工智能、AIGC、python、计算机视觉相关分享研究。 ✌更多学习资源&#xff0c;可关注公-仲-hao:【阿旭算法与机器学习】&#xff0c;共同学习交流~ &#x1f44d;感谢小伙伴们点赞、关注&#xff01; 《------往期经典推…
阅读更多...
易语言窗口1以及其它子窗口在任务栏显示的方法以及源代码

易语言窗口1以及其它子窗口在任务栏显示的方法以及源代码

大家都知道在启动子程序中载入窗口里&#xff0c;窗口就不在任务栏中显示了 用什么办法可以解决这个问题呢 本例程教源码教你如何解决
阅读更多...
零拷贝：原理与实现

零拷贝：原理与实现

1. 简介 I/O 或输入/输出通常意味着中央处理器 (CPU) 与外部设备&#xff08;如磁盘、鼠标、键盘等&#xff09;之间的读写。在深入研究零拷贝之前&#xff0c;有必要指出磁盘 I/O&#xff08;包括磁盘设备和其他块导向设备&#xff09;和网络 I/O 之间的区别。 磁盘 I/O 的常…
阅读更多...
Vue3简单介绍和快速体验

Vue3简单介绍和快速体验

目录 前言 1. Vue3介绍 1.1 Vue的两个核心功能&#xff1a; 1.2 Vue作者介绍 2. Vue3快速体验(非工程化方式) 2.1 所有代码 2.2 导入js 2.3 一些基本指令 2.4 app对象的创建和挂载 ​ 前言 在学习Vue3之前,自己已经学习过的vue2了,在学习Vue3后还是能感觉到2和3在使用…
阅读更多...
媒体资讯视频数据采集-yt-dlp-python实际使用-下载视频

媒体资讯视频数据采集-yt-dlp-python实际使用-下载视频

对于视频二创等一些业务场景&#xff0c;可能要采集youtube等的相关媒体视频资源&#xff0c;使用[yt-dlp](https://github.com/yt-dlp/yt-dlp)是一个不错的选择&#xff0c;提供的命令比较丰富&#xff0c;场景比较全面yt-dlp 是一个用 Python 编写的命令行工具&#xff0c;主…
阅读更多...
数据结构和算法｜递归算法那些事（递归算法的时间复杂度和尾递归优化）

数据结构和算法｜递归算法那些事（递归算法的时间复杂度和尾递归优化）

对于文章的第一部分&#xff0c;递归算法的时间复杂度&#xff0c;来自于代码随想录文章:通过一道面试题目&#xff0c;讲一讲递归算法的时间复杂度&#xff01; 对于第二节尾递归优化来自于B站&#xff1a;尾递归优化&#xff1a;你的递归调用是如何被优化的&#xff1f; 关于…
阅读更多...
什么是占空比？什么是周期？什么是频率？

什么是占空比？什么是周期？什么是频率？

一、什么是占空比&#xff1f; 占空比(Duty Cycle)是脉冲信号中高电平持续时间与整个周期时间的比率。它通常用于描述脉冲宽度调制(PWM)信号&#xff0c;其中信号在一定频率下在高电平和低电平之间切换。 图1.1 60%占空比信号 占空比计算公式如下&#xff1a; 脉冲高电平持续时…
阅读更多...
护眼首选，一线智联！AOC Q27E12C商用显示器，摆脱束缚高效办公！

护眼首选，一线智联！AOC Q27E12C商用显示器，摆脱束缚高效办公！

摘要&#xff1a;QHD广色域护眼显示器&#xff0c;减负提效商务利器&#xff01; 不管是日常处理报表、制作方案还是进行文字创作、设计剪辑&#xff0c;都离不开商用显示器的身影。相较于传统显示器&#xff0c;商用显示器往往更有助于减负提效&#xff0c;提高企业生产力&am…
阅读更多...
开源24Mhz采样逻辑分析仪-信息搜集

开源24Mhz采样逻辑分析仪-信息搜集

引用&#xff1a; 开源4Mhz采样逻辑分析仪-信息搜集&#xff1a; Sigrok逻辑分析仪软件(基于CY7C68013A)-CSDN博客 迷你逻辑分析仪TYPE C接口单片机ARM FPGA调试工具24M采样8通道_逻辑分析仪24m能测stm32吗-CSDN博客 nanoDLA逻辑分析仪上手教程-CSDN博客 基于cy7c68013的逻…
阅读更多...
嵌入式初学-C语言-练习四

嵌入式初学-C语言-练习四

一维数组练习题 1.键盘录入一组数列&#xff0c;利用冒泡排序将数据由大到小排序 代码&#xff1a; 1 /*2 需求&#xff1a;一维数组案例-冒泡排序3 */4 #include <stdio.h>5 6 int main()7 {8 //创建一个数组&#xff0c;用来存储排序的数列9 int arr[10];1…
阅读更多...
Redis远程字典服务器（2） —— 全局命令

Redis远程字典服务器（2） —— 全局命令

一&#xff0c;使用官方文档 学会使用文档&#xff0c;是一个优秀程序员的必备技能。Redis的命令非常多&#xff08;上百个&#xff09;&#xff0c;因为Redis是通过键值对存储数据的&#xff0c;key为string类型&#xff0c;但是value可以是其它的数据类型&#xff08;字符串…
阅读更多...
javascript-动态增加和删除表格的行

javascript-动态增加和删除表格的行

本地环境&#xff1a;win10 / centos6 &#xff0c; python3 实现效果 点击添加峰图按钮即可增加一行&#xff0c;点击每行右侧的删除按钮即可删除行。 初始状态&#xff1a; 点击后&#xff1a; 实际生成的html内容类似下图&#xff0c;可以看到&#xff0c;只有id这样需要…
阅读更多...
VMware capacity mismatch for disk错误解决办法

VMware capacity mismatch for disk错误解决办法

因为业务或者学习很多时候我们要用到虚拟机&#xff0c;当我们使用vmware去打开VirtualBox导出的文件虚拟机镜像时会发生capacity mismatch for disk错误&#xff0c;同时在网上查询没有完整通俗易懂的解决方案&#xff0c;我本人也遇到了这个错误&#xff0c;经过测试以后写下…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023