赞
踩
目录
Qt:Qfile与QTextStream读写文本文件(*****)
Qt QFile按行读写数据 (*****)
[C++]Qt文本操作(按行读写)(***)
lines.push_back(line); //将每一行依次存入到vector中
官方手册:readLine()
----------------------------------
参考:
Qt:Qfile与QTextStream读写文本文件 + Qt QFile /readLine()(****)
Qt:Qfile与QTextStream读写文本文件 + Qt QFile /readLine()(****)_ken2232的博客-CSDN博客
C++操作文件行(读取,删除,修改指定行) (****)
C++操作文件行(读取,删除,修改指定行) (****)_ken2232的博客-CSDN博客
Qt 之QDir文件目录拷贝、创建、删除 (***)
Qt 之QDir文件目录拷贝、创建、删除 (***)_ken2232的博客-CSDN博客
Qt之Qfile读取文件操作:类介绍
Qt之Qfile读取文件操作:类介绍_qfile读取文件的任意位置_ken2232的博客-CSDN博客
C++ 读取文件最后一行产生的问题
C++ 读取文件最后一行产生的问题_ken2232的博客-CSDN博客
==================
命名空间:
功能相似的局部函数:read() /write() 函数的名字相同,功能相同;但是,实际上,它们都是局部函数,也就是在不同的类中的具体实现,一般都是不一样的。
人也类似:都叫张三,这个城市的张三,和那个城市的张三,它们的身体构造,基本上都具备雄性人类的大部分、甚至是绝大部分的主要特征,但是,它们根本上就不是同一个人。
如果采用身份证号码来取代人名的话:这个号码的人就几乎完全不同于那个号码的人了。没有绝对,由于种种原因,可能同一个人同时有几个号码,或者同一个号码却同时表示几个不同的人。
问题:
1. 假如使用身份证号码来取代人名的话:没有效率,点100个人名,可能需要半天时间了。
2. 类似的100个事件,就要使用类似的100个相近的不同标记,太难记忆了。
3. 局部作用域,只要这个城市张三的老婆,不会搞混淆哪个张三是自己老公,就OK 了。
有心想用一个 write()函数就能够适用于所有的 write场景,甚至是一切场景;有心想用一种药就能包治百病;可惜,人类永远也做不到啊?
================================
1. 包含的头文件
- #include <QDebug>
- #include <QFile>
2. 读数据
- QFile file("inputFile.txt");
- if (file.open(QIODevice::ReadOnly | QIODevice::Text))
- {
- while (!file.atEnd())
- {
- QByteArray line = file.readLine();
- }
- file.close();
- }
3. 写数据
- QFile file("outputFile.txt");
- if (file.open(QIODevice::ReadWrite | QIODevice::Text))
- {
- file.write(str);
- file.flush();
- file.close();
- }
https://www.cnblogs.com/FKdelphi/p/10310435.html
#include <QDebug>
#include <QFile>void ReadLine()
{QFile file("要读的文件路径");
if (file.open(QIODevice::ReadOnly | QIODevice::Text))
{
while (!file.atEnd())
{
QByteArray line = file.readLine();
QString str(line);
qDebug() << str;
displayString << str;
}
file.close();}
}
void WriteLine()
{QFile file("要写的文件路径");
if (file.open(QIODevice::ReadWrite | QIODevice::Text))
{
QTextStream stream(&file);
stream.seek(file.size());
for (auto& i : displayString)
{
QString qs;
qs.append("Content:");
qs.append(i);
qs.remove("\n");
stream << qs << "\n";
}
file.close();
}
}
QString转换为QByteArray
QByteArray byte;
QString string;
byte = string.toAscii();byte = string.toUtf8();
QByteArray 转换为 QStringQByteArray byte;
QString string;
string = QString(byte);string.prepend(byte);
=============
https://blog.csdn.net/qq_44894692/article/details/106650975
之前总结了几种用C++读写文本文件的方法,这几天用Qt时大概学了一下用Qt中的Qfile和QTextStream读写文本文件,在此做个记录。
之前对C++读写文本文件的几种方法比较:https://blog.csdn.net/qq_44894692/article/details/103618356
void readwrite::readfile()
{
QString path = QFileDialog::getOpenFileName(this, "open", "../", "txt(*.txt)");//读取文件路径
if (!path.isEmpty())
{
QFile file(path);
bool isok = file.open(QIODevice::ReadOnly);//打开方式为只读
if (isok)
{
QByteArray array = file.readAll();//读取文本中全部文件
ui.textBrowser->setText(QString(array));
}
file.close();//关闭文件
}
}
void readwrite::writefile()
{
QString path = QFileDialog::getSaveFileName(this, "save", "../", "txt(*.txt)");//写出文件的路径
if (!path.isEmpty())
{
QFile file(path);
bool isok = file.open(QIODevice::WriteOnly);//打开方式为只写
if (isok)
{
QString str = ui.textBrowser->toPlainText(); //获取文本框中的内容
file.write(str.toUtf8()); //
}
file.close();
}
}
void readwrite::readfile()
{
QString path = QFileDialog::getOpenFileName(this, "open", "../", "txt(*.txt)");
if (!path.isEmpty())
{
QFile file(path);
bool isok = file.open(QIODevice::ReadOnly);
if (isok)
{
QTextStream filestream(&file); //QTextStream 与file关联
QString str;
filestream.setCodec("UTF-8");
while (filestream.atEnd()==false)
{
str.append(filestream.readLine());//逐行读取
str.append("\n");
//str = filestream.readAll();//一次性读取全部文件
}
ui.textBrowser->setText(str);
}
file.close();
}
}
void readwrite::writefile()
{
QString path = QFileDialog::getSaveFileName(this, "save", "../", "txt(*.txt)");
if (!path.isEmpty())
{
QFile file(path);
bool isok = file.open(QIODevice::WriteOnly);
if (isok)
{
QTextStream filestream(&file); //QTextStream 与file关联
QString str = ui.textBrowser->toPlainText();
filestream << str;//写出文件
qDebug() << str;
}
file.close();
}
}
使用Qt读写文本文件通常使用Qfile与QTextStream 结合,因为QTextStream 可以逐行读取,对于处理数据要相对方便一些,而且Qt提供了较多的函数接口,较C++要更快速便捷。
————————————————
版权声明:本文为CSDN博主「BetterQ.」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/qq_44894692/article/details/106650975
前几天要用到C++读取文本文件,就学习了一下几种不同的读取方法:
文本文件内容如下:
int main()
{
ifstream infile;
infile.open("qqzl.txt", ios::in);
if (!infile.is_open())
{
cout << "读取文件失败" << endl;
return;
}
//第一种读取方法,
char buf[1024] = { 0 };
while (infile>>buf)
{
cout << buf << endl;//输出读取的文本文件数据
}
}
int main()
{
ifstream infile;
infile.open("qqzl.txt", ios::in);
if (!infile.is_open())
{
cout << "读取文件失败" << endl;
return;
}
//第二种读取方法
char buf[1024];
while (infile.getline(buf,sizeof(buf)))
{
cout << buf << endl;
}
}
int main()
{
ifstream infile;
infile.open("qqzl.txt", ios::in);
if (!infile.is_open())
{
cout << "读取文件失败" << endl;
return;
}
//第三种读取方法
string buf;
while (getline(infile,buf))
{
cout << buf << endl;
}
}
int main()
{
ifstream infile;
infile.open("qqzl.txt", ios::in);
if (!infile.is_open())
{
cout << "读取文件失败" << endl;
return;
}
//第四种读取方法
char c;
while ((c=infile.get())!=EOF)
{
cout << c;
}
}
int main()
{
ifstream infile;
infile.open("qqzl.txt", ios::in);
if (!infile.is_open())
{
cout << "读取文件失败" << endl;
return;
}
//第五种读取方法
string s;
vector<string>v1;
while (getline(infile,s))
{
infile >> s;
v1.push_back(s);
}
for (int i = 0; i < v1.size(); i++)
{
cout << v1.at(i);
cout << endl;
}
infile.close();
}
这是暂时总结的几种方法,就当记录一下。
————————————————
版权声明:本文为CSDN博主「BetterQ.」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/qq_44894692/article/details/103618356
====================================
qint64 QIODevice::readLine(char *data, qint64 maxSize)
This function reads a line of ASCII characters from the device, up to a maximum of maxSize - 1 bytes, stores the characters in data, and returns the number of bytes read. If a line could not be read but no error ocurred, this function returns 0. If an error occurs, this function returns the length of what could be read, or -1 if nothing was read.
A terminating '\0' byte is always appended to data, so maxSize must be larger than 1.
Data is read until either of the following conditions are met:
The first '\n' character is read.maxSize - 1 bytes are read.The end of the device data is detected.
For example, the following code reads a line of characters from a file:
QFile file("box.txt");
if (file.open(QFile::ReadOnly))
{
char buf[1024];
qint64 lineLength = file.readLine(buf, sizeof(buf));
if (lineLength != -1) {
// the line is available in buf
}
}
The newline character ('\n') is included in the buffer. If a newline is not encountered before maxSize - 1 bytes are read, a newline will not be inserted into the buffer. On windows newline characters are replaced with '\n'.
This function calls readLineData(), which is implemented using repeated calls to getChar(). You can provide a more efficient implementation by reimplementing readLineData() in your own subclass.
See also getChar(), read(), and write().
QByteArray QIODevice::readLine(qint64 maxSize = 0)
This is an overloaded function.
Reads a line from the device, but no more than maxSize characters, and returns the result as a byte array.
This function has no way of reporting errors; returning an empty QByteArray can mean either that no data was currently available for reading, or that an error occurred.
[virtual protected] qint64 QIODevice::readLineData(char *data, qint64 maxSize)
Reads up to maxSize characters into data and returns the number of characters read.
This function is called by readLine(), and provides its base implementation, using getChar(). Buffered devices can improve the performance of readLine() by reimplementing this function.
readLine() appends a '\0' byte to data; readLineData() does not need to do this.
If you reimplement this function, be careful to return the correct value: it should return the number of bytes read in this line, including the terminating newline, or 0 if there is no line to be read at this point. If an error occurs, it should return -1 if and only if no bytes were read. Reading past EOF is considered an error.
Reads one line of text from the stream, and returns it as a QString. The maximum allowed line length is set to maxlen. If the stream contains lines longer than this, then the lines will be split after maxlen characters and returned in parts.
If maxlen is 0, the lines can be of any length.
The returned line has no trailing end-of-line characters ("\n" or "\r\n"), so calling QString::trimmed() can be unnecessary.
If the stream has read to the end of the file, readLine() will return a null QString. For strings, or for devices that support it, you can explicitly test for the end of the stream using atEnd().
See also readAll() and QIODevice::readLine().
-------------------------------------
The QFile class provides an interface for reading from and writing to files. More...
Header: | #include <QFile> |
qmake: | QT += core |
Inherits: | |
Inherited By: |
Note: All functions in this class are reentrant.
typedef |
QFile(const QString &name, QObject *parent) | |
QFile(QObject *parent) | |
QFile(const QString &name) | |
QFile() | |
virtual | ~QFile() |
bool | copy(const QString &newName) |
bool | exists() const |
bool | link(const QString &linkName) |
bool | open(FILE *fh, QIODevice::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle) |
bool | open(int fd, QIODevice::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle) |
bool | remove() |
bool | rename(const QString &newName) |
void | setFileName(const QString &name) |
QString | symLinkTarget() const |
virtual QString | fileName() const override |
virtual bool | open(QIODevice::OpenMode mode) override |
virtual QFileDevice::Permissions | permissions() const override |
virtual bool | resize(qint64 sz) override |
virtual bool | setPermissions(QFileDevice::Permissions permissions) override |
virtual qint64 | size() const override |
bool | copy(const QString &fileName, const QString &newName) |
QString | decodeName(const QByteArray &localFileName) |
QString | decodeName(const char *localFileName) |
QByteArray | encodeName(const QString &fileName) |
bool | exists(const QString &fileName) |
bool | link(const QString &fileName, const QString &linkName) |
QFileDevice::Permissions | permissions(const QString &fileName) |
bool | remove(const QString &fileName) |
bool | rename(const QString &oldName, const QString &newName) |
bool | resize(const QString &fileName, qint64 sz) |
bool | setPermissions(const QString &fileName, QFileDevice::Permissions permissions) |
QString | symLinkTarget(const QString &fileName) |
QFile is an I/O device for reading and writing text and binary files and resources. A QFile may be used by itself or, more conveniently, with a QTextStream or QDataStream.
The file name is usually passed in the constructor, but it can be set at any time using setFileName(). QFile expects the file separator to be '/' regardless of operating system. The use of other separators (e.g., '\') is not supported.
You can check for a file's existence using exists(), and remove a file using remove(). (More advanced file system related operations are provided by QFileInfo and QDir.)
The file is opened with open(), closed with close(), and flushed with flush(). Data is usually read and written using QDataStream or QTextStream, but you can also call the QIODevice-inherited functions read(), readLine(), readAll(), write(). QFile also inherits getChar(), putChar(), and ungetChar(), which work one character at a time.
The size of the file is returned by size(). You can get the current file position using pos(), or move to a new file position using seek(). If you've reached the end of the file, atEnd() returns true.
The following example reads a text file line by line:
QFile file("in.txt");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
while (!file.atEnd()) {QByteArray line = file.readLine();
process_line(line);
}
The QIODevice::Text flag passed to open() tells Qt to convert Windows-style line terminators ("\r\n") into C++-style terminators ("\n"). By default, QFile assumes binary, i.e. it doesn't perform any conversion on the bytes stored in the file.
The next example uses QTextStream to read a text file line by line:
QFile file("in.txt");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QTextStream in(&file);while (!in.atEnd()) {
QString line = in.readLine();
process_line(line);
}
QTextStream takes care of converting the 8-bit data stored on disk into a 16-bit Unicode QString. By default, it assumes that the user system's local 8-bit encoding is used (e.g., UTF-8 on most unix based operating systems; see QTextCodec::codecForLocale() for details). This can be changed using QTextStream::setCodec().
To write text, we can use operator<<(), which is overloaded to take a QTextStream on the left and various data types (including QString) on the right:
QFile file("out.txt");
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
return;
QTextStream out(&file);out << "The magic number is: " << 49 << "\n";
QDataStream is similar, in that you can use operator<<() to write data and operator>>() to read it back. See the class documentation for details.
When you use QFile, QFileInfo, and QDir to access the file system with Qt, you can use Unicode file names. On Unix, these file names are converted to an 8-bit encoding. If you want to use standard C++ APIs (<cstdio> or <iostream>) or platform-specific APIs to access files instead of QFile, you can use the encodeName() and decodeName() functions to convert between Unicode file names and 8-bit file names.
On Unix, there are some special system files (e.g. in /proc) for which size() will always return 0, yet you may still be able to read more data from such a file; the data is generated in direct response to you calling read(). In this case, however, you cannot use atEnd() to determine if there is more data to read (since atEnd() will return true for a file that claims to have size 0). Instead, you should either call readAll(), or call read() or readLine() repeatedly until no more data can be read. The next example uses QTextStream to read /proc/modules line by line:
QFile file("/proc/modules");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QTextStream in(&file);QString line = in.readLine();
while (!line.isNull()) {
process_line(line);
line = in.readLine();
}
Unlike other QIODevice implementations, such as QTcpSocket, QFile does not emit the aboutToClose(), bytesWritten(), or readyRead() signals. This implementation detail means that QFile is not suitable for reading and writing certain types of files, such as device files on Unix platforms.
File permissions are handled differently on Unix-like systems and Windows. In a non writable directory on Unix-like systems, files cannot be created. This is not always the case on Windows, where, for instance, the 'My Documents' directory usually is not writable, but it is still possible to create files in it.
Qt's understanding of file permissions is limited, which affects especially the QFile::setPermissions() function. On Windows, Qt will set only the legacy read-only flag, and that only when none of the Write* flags are passed. Qt does not manipulate access control lists (ACLs), which makes this function mostly useless for NTFS volumes. It may still be of use for USB sticks that use VFAT file systems. POSIX ACLs are not manipulated, either.
See also QTextStream, QDataStream, QFileInfo, QDir, and The Qt Resource System.
-------------------------
The QFile class provides an interface for reading from and writing to files. More...
Header:
#include <QFile>
qmake:
QT += core
Inherits:
QFileDevice
Inherited By:
QTemporaryFile
Writes at most maxSize bytes of data from data to the device. Returns the number of bytes that were actually written, or -1 if an error occurred.
See also read() and writeData().
qint64 QIODevice::write(const char *data)
This is an overloaded function.
Writes data from a zero-terminated string of 8-bit characters to the device. Returns the number of bytes that were actually written, or -1 if an error occurred. This is equivalent to
...
QIODevice::write(data, qstrlen(data));
...
This function was introduced in Qt 4.5.
See also read() and writeData().
qint64 QIODevice::write(const QByteArray &byteArray)
This is an overloaded function.
Writes the content of byteArray to the device. Returns the number of bytes that were actually written, or -1 if an error occurred.
See also read() and writeData().
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。