自学教程：C++ writeFile函数代码示例

int main(){    std::stringstream a_foldername;    a_foldername.str( std::string() );    a_foldername.clear();    a_foldername << "calibrationData" << "/" << getDate() << "_" << getTime() << "/";    std::cout << "Folder: " << a_foldername.str() << std::endl;    std::stringstream a_filename;    a_filename.str( std::string() );    a_filename.clear();    a_filename << "pointsGen.csv";    std::cout << "File: " << a_filename.str() << std::endl;    std::string a_filepath = writeFile( a_foldername.str(), a_filename.str() );    readFile( a_filepath );    return 0;}

bool LOCACC::deleteScreen(QTreeWidgetItem *currentItem){    QString screenId = currentItem->text(0);    QJsonArray locArray = m_jsonMasterObj["locAccData"].toArray();    QJsonObject tempObj;    for(int i = 0 ; i < locArray.count() ; i++)    {        tempObj = locArray.at(i).toObject();        if(tempObj["id"] == screenId)        {            locArray.removeAt(i);            break;        }    }    m_jsonMasterObj["locAccData"] = locArray;    currentItem->parent()->removeChild(currentItem);    emptyTreeWidget(currentItem);    writeFile();    return true;}

int main(int argc, char* argv[]){    POINT** points = NULL;    if(argc > 1)    {        points = readFile(argv[1]);        if(points != NULL)        {            display(points,12);            polygon(points, 12);            display(points, 12);            writeFile(points, 13, argv[1]);            destroyPoint(points, 13);        }    }    return 0;}

void GaussianBeamWindow::saveFile(const QString& path){	QSettings settings;	QString fileName = path;	QString dir = settings.value("GaussianBeamWindow/lastDirectory", "").toString();	if (fileName.isNull())		fileName = QFileDialog::getSaveFileName(this, tr("Save File"), dir, "*.xml");	if (fileName.isEmpty())		return;	if (!fileName.endsWith(".xml"))		fileName += ".xml";	if (writeFile(fileName))	{		setCurrentFile(fileName);		statusBar()->showMessage(tr("File") + " " + QFileInfo(fileName).fileName() + " " + tr("saved"));		settings.setValue("GaussianBeamWindow/lastDirectory", QFileInfo(fileName).path());	}}

static void kTermWriteFile(char *name){	FILE f;	unsigned char buffer[512] = "Let's write a file";	f=openFile(name,'w');	if(f.flags == FS_FILE_INVALID){		print("/r/nFile not found...");		closeFile(&f);		return;	} else if (f.flags== FS_DIRECTORY){		print("/r/n%s is a directory");		closeFile(&f);		return;	}	if(writeFile(&f,buffer,19) > 0)		print("Writing complete/r/n");	closeFile(&f);}

int ShibeTranslator::saveToFile(const QString &fileName){	QStringList resultList;	resultList.append(getMapList(&buttonMap,"Button_"));	resultList.append(getMapList(&labelMap,"Label_"));	resultList.append(getMapList(&checkBoxMap,"CheckBox_"));	resultList.append(getMapList(&groupBoxMap,"GroupBox_"));	resultList.append(getMapList(&spinBoxMap,"SpinBox_"));	resultList.append(getMapList(&stringMap,"String_"));	if(resultList.isEmpty())return 1;	resultList.sort();	QFile writeFile(fileName);	if(writeFile.open(QIODevice::WriteOnly|QIODevice::Truncate))	{		writeFile.write(QString(resultList.join("/r/n")+"/r/n").toUtf8());		writeFile.close();		return 0;	}	return 2;}

int main(int argc, const char * argv[]){    if (argc!=4) {        std::cout<<"patch command parameter:/n oldFileName diffFileName outNewFileName/n";        return 0;    }    const char* oldFileName=argv[1];    const char* diffFileName=argv[2];    const char* outNewFileName=argv[3];    std::cout<<"old :/"" <<oldFileName<< "/"/ndiff:/""<<diffFileName<<"/"/nout :/""<<outNewFileName<<"/"/n";    clock_t time0=clock();    {        std::vector<TByte> diffData; readFile(diffData,diffFileName);        const TUInt diffFileDataSize=(TUInt)diffData.size();        TUInt kNewDataSizeSavedSize=-1;        const hpatch_StreamPos_t _newFileDataSize=readSavedSize(diffData,&kNewDataSizeSavedSize);        const TUInt newDataSize=(TUInt)_newFileDataSize;        if (newDataSize!=_newFileDataSize) exit(1);        std::vector<TByte> oldData; readFile(oldData,oldFileName);        const TUInt oldDataSize=(TUInt)oldData.size();        std::vector<TByte> newData;        newData.resize(newDataSize);        TByte* newData_begin=0; if (!newData.empty()) newData_begin=&newData[0];        const TByte* oldData_begin=0; if (!oldData.empty()) oldData_begin=&oldData[0];        clock_t time1=clock();        if (!patch(newData_begin,newData_begin+newDataSize,oldData_begin,oldData_begin+oldDataSize,                   &diffData[0]+kNewDataSizeSavedSize, &diffData[0]+diffFileDataSize)){            std::cout<<"  patch run error!!!/n";            exit(3);        }        clock_t time2=clock();        writeFile(newData,outNewFileName);        std::cout<<"  patch ok!/n";        std::cout<<"oldDataSize : "<<oldDataSize<<"/ndiffDataSize: "<<diffData.size()<<"/nnewDataSize : "<<newDataSize<<"/n";        std::cout<<"/npatch   time:"<<(time2-time1)*(1000.0/CLOCKS_PER_SEC)<<" ms/n";    }    clock_t time3=clock();    std::cout<<"all run time:"<<(time3-time0)*(1000.0/CLOCKS_PER_SEC)<<" ms/n";    return 0;}

/* * Create a file on the disk */bool Directory::createFile(string path, string name, string &data) {	if (!initialised) throw std::runtime_error("Directory not Initialised");	if (isPathNameLegal(path) && isNameLegal(name)) {		// check the path is valid		int directoryNode = directoryTree->getPathNode(path);		if (directoryNode < 0) {			cout << "path " << path << " is invalid" << endl;			return false;		}		// cache the directory (path) if it is not already cached		int directoryNodeCache = getCachedDirectory(directoryNode);		// check the filename does not already exist		if (cachedDirectory[directoryNodeCache]->cache.count(name) > 0) {			cout << "file/Directory " << name << " already exists" << endl;			freeCachedDirectory(directoryNodeCache);			return false;		}		// create an INode		int fileBlock = freeBlockList->getBlock();		int fileNode = iNodeList->writeNewINode(false,data.length(),fileBlock);		iNodeList->lockINode(fileNode);		// write the file		if (!writeFile(fileNode,data)) {			iNodeList->unLockINode(fileNode);			freeCachedDirectory(directoryNodeCache);			return false;		}		// add the file to the directory		iNodeList->lockINode(directoryNode);		cachedDirectory[directoryNodeCache]->cache.insert({name,fileNode});		// write the directory		cachedDirectory[directoryNodeCache]->writeCachedDirectory();		iNodeList->unLockINode(directoryNode);		iNodeList->unLockINode(fileNode);		freeCachedDirectory(directoryNodeCache);		return true;	} else {		cout << "Path or filename not legal" << endl;		return false;	}}

static void* alsa_audio_start(void *aux){	audio_fifo_t *af = aux;	snd_pcm_t *h = NULL;	int c;	int cur_channels = 0;	int cur_rate = 0;	audio_fifo_data_t *afd;	for (;;) {		afd = audio_get(af);		if (!h || cur_rate != afd->rate || cur_channels != afd->channels) {			if (h) snd_pcm_close(h);			cur_rate = afd->rate;			cur_channels = afd->channels;            h = alsa_open("default", cur_rate, cur_channels);            if (!h) {                fprintf(stderr, "Unable to open ALSA device (%d channels, %d Hz), dying/n",                        cur_channels, cur_rate);                exit(1);            }		}		c = snd_pcm_wait(h, 1000);		if (c >= 0)			c = snd_pcm_avail_update(h);		if (c == -EPIPE)			snd_pcm_prepare(h);        snd_pcm_writei(h, afd->samples, afd->nsamples);        writeFile( &afd->samples );        zfree(afd);	}}

void Huffman::compressHuffmanToFile() {	std::cout << "- Huffman Code Compressed To ASCII. Saved To A New File/n/n"; // shhh.. not yet really. But it's going to happen below.	// pad the huffman code to create chunks of equal size (8-bits) - Reason... CPU reads min of a byte (8-bits)	while (huffmanCode.size() % 8 != 0) {		huffmanCode.append("0");		padding++;	}	std::string compressedCode;	std::stringstream sstream(huffmanCode);	std::bitset<8> byte;	bool innerControl = true; // I got none.	int i = 0; // this and the inner while loop is for the output of bit codes in 8 bit chunks	std::cout << std::right << std::setw(15) << "Character";	std::cout << " | ASCII Code" << std::endl;		while (sstream) { // this would add incorrect character at the end w/o the additional padding. Could've used .good() as well		sstream >> byte;		char c = char(byte.to_ulong());		compressedCode += c;		std::cout << std::right << std::setw(11) << " "; // this is just to pad the space on the left hand side		std::cout << c;		while (innerControl) {			std::cout << std::setw(15) << huffmanCode.substr(i, 8) << std::endl;			i += 8;			innerControl = false;		}		innerControl = true;	}	compressedCode.pop_back(); // this is to cut off the extra NUL (/0) at the end (Tip for whoever comes by this CA - Notepad++ points out NULs in text files)	// write out the compressed code to file	writeFile(compressedCode, "CompressedHuffman.txt");	std::cout << std::right << std::setw(6) << " " << "Output To File: " << compressedCode << "/n/n";}

void DataManager::generateXmlFile(){    XmlTree dataTree;    dataTree.setTag("QLT_Genome_Data");    dataTree.push_back(XmlTree("datapath","./data/exons/"));        XmlTree datas("datasets","");    for(int i=0;i<23;i++){        XmlTree dataset("dataset","");        dataset.setAttribute("id", i);        dataset.push_back( XmlTree("title","Chromosome "+toString(i+1)) );        dataset.push_back( XmlTree("map","exons."+toString(i+1)+".locations") );        dataset.push_back( XmlTree("bases","exons."+toString(i+1)+".bases") );        datas.push_back( dataset );    }    dataTree.push_back( datas );    DataTargetPathRef f = writeFile( getAssetPath( "QLT_Genome_Data.xml" ), true );    dataTree.write( f );    }

void Module::genhdrfile(){    OutBuffer hdrbufr;    hdrbufr.doindent = 1;    hdrbufr.printf("// D import file generated from '%s'", srcfile->toChars());    hdrbufr.writenl();    HdrGenState hgs;    memset(&hgs, 0, sizeof(hgs));    hgs.hdrgen = 1;    toCBuffer(&hdrbufr, &hgs);    // Transfer image to file    hdrfile->setbuffer(hdrbufr.data, hdrbufr.offset);    hdrbufr.data = NULL;    ensurePathToNameExists(Loc(), hdrfile->toChars());    writeFile(loc, hdrfile);}

int ShaderD3D::prepareSourceAndReturnOptions(std::stringstream *shaderSourceStream){    uncompile();    int additionalOptions = 0;    const std::string &source = mData.getSource();#if !defined(ANGLE_ENABLE_WINDOWS_STORE)    if (gl::DebugAnnotationsActive())    {        std::string sourcePath = getTempPath();        writeFile(sourcePath.c_str(), source.c_str(), source.length());        additionalOptions |= SH_LINE_DIRECTIVES | SH_SOURCE_PATH;        *shaderSourceStream << sourcePath;    }#endif    *shaderSourceStream << source;    return additionalOptions;}

static void writePeerCerts(	CFArrayRef			peerCerts,	const char			*fileBase){	CFIndex numCerts;	SecCertificateRef certRef;	CFIndex i;	char fileName[100];		if(peerCerts == NULL) {		return;	}	numCerts = CFArrayGetCount(peerCerts);	for(i=0; i<numCerts; i++) {		sprintf(fileName, "%s%02d.cer", fileBase, (int)i);		certRef = (SecCertificateRef)CFArrayGetValueAtIndex(peerCerts, i);		writeFile(fileName, SecCertificateGetBytePtr(certRef),			SecCertificateGetLength(certRef));	}	printf("...wrote %lu certs to fileBase %s/n", numCerts, fileBase);}

voidsaveFile(void){	int i, len;	word *pTable;	writeFile("dccs", 4);					/* Signature */					writeFileShort(numKeys);				/* Number of keys */	writeFileShort((short)(numKeys * C));	/* Number of vertices */	writeFileShort(PATLEN);					/* Length of key part of entries */	writeFileShort(SYMLEN);					/* Length of symbol part of entries */	/* Write out the tables T1 and T2, with their sig and byte lengths in front */	writeFile("T1", 2);						/* "Signature" */	pTable = readT1();	len = PATLEN * 256;	writeFileShort(len * sizeof(word));	for (i=0; i < len; i++)	{		writeFileShort(pTable[i]);	}	writeFile("T2", 2);	pTable = readT2();	writeFileShort(len * sizeof(word));	for (i=0; i < len; i++)	{		writeFileShort(pTable[i]);	}	/* Write out g[] */	writeFile("gg", 2);			  			/* "Signature" */	pTable = readG();	len = (short)(numKeys * C);	writeFileShort(len * sizeof(word));	for (i=0; i < len; i++)	{		writeFileShort(pTable[i]);	}	/* Now the hash table itself */	writeFile("ht ", 2);			  			/* "Signature" */	writeFileShort(numKeys * (SYMLEN + PATLEN + sizeof(word)));	/* byte len */	for (i=0; i < numKeys; i++)	{		writeFile((char *)&keys[i], SYMLEN + PATLEN);	}}

handleInterrupt21(int ax, int bx, int cx, int dx){   if(ax==0)   	printString(bx);   if(ax==1)   	readString(bx);   if(ax==2)   	readSector(bx,cx);   if(ax==3)   	readfile(bx,cx);    if(ax==4)     executeProgram(bx,cx);   if(ax==5)   	terminate();   if(ax==6)    writeSector(bx,cx);   if(ax==7)   	deleteFile(bx);   if(ax==8)   	 writeFile(bx,cx,dx);   if(ax>=9)   	printString("Error"); }

void Module::gensymfile(){    OutBuffer buf;    HdrGenState hgs;    //printf("Module::gensymfile()/n");    buf.printf("// Sym file generated from '%s'", srcfile->toChars());    buf.writenl();    for (size_t i = 0; i < members->dim; i++)    {        Dsymbol *s = (*members)[i];        s->toCBuffer(&buf, &hgs);    }    // Transfer image to file    symfile->setbuffer(buf.data, buf.offset);    buf.data = NULL;    writeFile(loc, symfile);}

void implFFT(std::string name, InputCopy<double>* i, OutputCopy<double>* o, Parameters<double> conf){	auto input = new FileInput<double>("input_mono.wav", i, conf);	auto output = new FileOutput<double>(o, conf);	FFT_p<double> fft_m(new FFTWManager<double>(conf));	fft_m->setChannels((unsigned int) input->channels());	auto fft_i = new FFTInputProxy<double>(new RectWindow<double>,										   input,										   fft_m,										   conf);	auto fft_o = new FFTOutputProxy<double>(output, fft_m, conf);	BenchmarkManager manager(Input_p(fft_i),							 Output_p(fft_o),							 Benchmark_p(new Dummy<double>(conf)));	manager.execute();	output->writeFile(("out_test_copy_fft_" + name + ".wav").c_str());}

/*********************************************************** * DESCRIPTION:  *    Core function for writing data w/o using VB cache *    (bulk load dictionary store inserts) ***********************************************************/int DbFileOp::writeDBFileNoVBCache( IDBDataFile* pFile,                                    const unsigned char* writeBuf,                                    const int fbo,                                    const int numOfBlock  ){#ifdef PROFILE    // This function is only used by bulk load for dictionary store files,    // so we log as such.    Stats::startParseEvent(WE_STATS_WRITE_DCT);#endif    for( int i = 0; i < numOfBlock; i++ ) {        Stats::incIoBlockWrite();        RETURN_ON_ERROR( writeFile( pFile, writeBuf, BYTE_PER_BLOCK ) );    }#ifdef PROFILE    Stats::stopParseEvent(WE_STATS_WRITE_DCT);#endif    return NO_ERROR;}

int main(int argc, char *argv[]){   char *prefix;   FILE *f;   int size;   if (argc != 4) {      fprintf(stderr, "Argument error/n");      return -1;   }         f = fopen(argv[1], "w");   if (!f) {      fprintf(stderr, "Failed to open %s: %s/n", argv[2], strerror(errno));      return -1;   }   size = atoi(argv[2]);   prefix = argv[3];   writeFile(f, prefix, size);   return 0;}

/*  * Appends a new system activity log message to the  * end of the "log.txt" file. */void logActivity(char *activity) {    char message[2000];    time_t rawtime;    struct tm * timeinfo;    /* Obtain the current system time. */    time(&rawtime);    timeinfo = localtime(&rawtime);    message[0] = '/0';    /* Create the log message. */    strcat(message, "LOG - EM: ");    strcat(message, activity);    strcat(message, " - ");    strcat(message, asctime(timeinfo));    /* Write the log message to the log file (log.txt). */    writeFile("../files/log.txt", message);}

void putfilelist (list_ref list, char *filename, int after) {    FILE *input;    if(after == 2) {        input = fopen (filename, "w");    } else {        input = fopen (filename, "r");    }    if (input == NULL) {        fflush (NULL);        fprintf (stderr, "%s: %s: %s/n",                 Exec_Name, filename, strerror (errno));        fflush (NULL);        Exit_Status  = EXIT_FAILURE;    } else {        if(after == 2) {            writeFile(list, input);        } else {            putFileinList(list, input, filename, after);        }        fclose (input);    }}

bool WiiSave::saveToFile(const std::string& filepath, Uint8* macAddress, Uint32 ngId, Uint8* ngPriv, Uint8* ngSig, Uint32 ngKeyId){    m_writer = new BinaryWriter(filepath);    m_writer->setAutoResizing(true);    m_writer->setEndianess(Stream::BigEndian);    writeBanner();    m_writer->writeUInt32(0x70);    m_writer->writeUInt32(0x426B0001);    m_writer->writeUInt32(ngId); // NG-ID    m_writer->writeUInt32(m_files.size());    m_writer->writeUInt32(0); // Size of files;    m_writer->seek(8);    m_writer->writeUInt32(0); // totalSize    m_writer->seek(64);    m_writer->writeUInt64(m_banner->gameID());    m_writer->writeBytes((Int8*)macAddress, 6);    m_writer->seek(2); // unknown;    m_writer->seek(0x10); // padding;    Uint32 totalSize = 0;    for (std::map<std::string, WiiFile*>::const_iterator iter = m_files.begin(); iter != m_files.end(); ++iter)    {        totalSize += writeFile(iter->second);    }    int pos = m_writer->position();    // Write size data    m_writer->seek(0xF0C0 + 0x10, Stream::Beginning);    m_writer->writeUInt32(totalSize);    m_writer->seek(0xF0C0 + 0x1C, Stream::Beginning);    m_writer->writeUInt32(totalSize + 0x3c0);    m_writer->seek(pos, Stream::Beginning);    writeCerts(totalSize, ngId, ngPriv, ngSig, ngKeyId);    m_writer->save();    return true;}

intmain (){	int n;	double *x, *f, *g;	printf ("/nEntreu les coordenades/n");	x = HGVM (&n);	printf ("/nEntreu els valors de la funcio/n");	f = GVM (n);	printf ("/nEntreu les derivades/n");	g = GVM (n);/* Obte el polinomi desitjat */	difdivherm (n, &x, &f, &g);/* Dibuixa el polinomi */	writeFile (2 * n, 1e-2, -2, 2, x, f);	FV (x, n);	FV (f, n);	return 0;}

static int rt_digest(opParams *op){	int 		irtn;	CSSM_DATA	ptext;	CSSM_DATA	digest = {0, NULL};	CSSM_RETURN	crtn;	unsigned	len;		if((op->plainFileName == NULL) || (op->sigFileName == NULL)) {		printf("***Need plainFileName and sigFileName to digest./n");		return 1;	}	irtn = readFile(op->plainFileName, &ptext.Data, &len);	if(irtn) {		printf("***Error reading %s/n", op->plainFileName);		return irtn;	}	ptext.Length = len;	crtn = cspDigest(op->cspHand,		op->alg,		CSSM_FALSE,		// mallocDigest - let CSP do it		&ptext,		&digest);	if(crtn) {		printError("cspDigest", crtn);		return 1;	}	irtn = writeFile(op->sigFileName, digest.Data, digest.Length);	if(irtn) {		printf("***Error writing %s/n", op->sigFileName);	}	else if(!op->quiet){		printf("...wrote %lu bytes to %s/n", digest.Length, op->sigFileName);	}	free(ptext.Data);						// allocd by readFile	appFreeCssmData(&digest, CSSM_FALSE);	// by CSP	return irtn;}

bool LOCACC::updateElement(QStringList newElementData, QTreeWidgetItem *currentItem){    QString elementId = currentItem->text(0);    QJsonArray jArray = m_jsonMasterObj["locAccData"].toArray();    QString parentScreen = currentItem->parent()->text(0);    QJsonObject tempObj ;    for(int i = 0 ; i < jArray.count() ; i++ )    {        tempObj = jArray.at(i).toObject();        if(tempObj["id"] == parentScreen)        {            QJsonArray eleJArray = tempObj["elements"].toArray();            QJsonObject eleObject ;            for(int j = 0 ; j < eleJArray.count() ; j++)            {                eleObject = eleJArray.at(j).toObject();                if(eleObject["id"] == elementId)                {                    eleJArray.removeAt(j);                    if(elementExistance(newElementData,eleJArray))                    {                        return false;                    }                    QJsonObject newEleJson = getElementJson(newElementData);                    newEleJson["messages"] = eleObject["messages"];                    eleJArray.insert(j,newEleJson);                    tempObj["elements"] = eleJArray;                    jArray.replace(i,tempObj);                    break;                }            }        }    }    m_jsonMasterObj["locAccData"] = jArray;    currentItem->setText(0,newElementData.at(0));    writeFile();    return true;}

int main( int argc, char** argv ){  //// User's choice  if ( argc == 1 )    {      std::cout << "Usage: " << argv[0] << "<output> <inputFile1> <inputFile2> ..." << std::endl;      std::cout << "       - computes the difference of results between the" << std::endl;      std::cout << "         CPU version of the estimator and the GPU version" << std::endl;      std::cout << "         GPU file : positions are between [0;size]." << std::endl;      std::cout << "         CPU file : positions are between [0;2*size]" << std::endl;      std::cout << "                                       or [-size;size]." << std::endl;      std::cout << "         Error type : 1 is l_1, 2 is l_2, 3 is l_//infty." << std::endl;      std::cout << "Example:" << std::endl;      std::cout << argv[ 0 ] << " file1.txt file2.txt 64 3" << std::endl;      return 0;    }  std::string fileOutput = argc > 1 ? std::string( argv[ 1 ] ) : "file1.txt";  std::string fileInput = argc > 2 ? std::string( argv[ 2 ] ) : "file2.txt";  convertCPUtoKhalimsky predicateCPU;  std::vector< std::pair<Position*, Curvatures*> > v_export;  std::vector< std::pair<Position*, Value> > v_temp;  loadFile2( fileInput, v_temp, predicateCPU );  writeVector(v_temp, v_export, 0 );  deleteVector2( v_temp );  for(int i = 3; i < argc; ++i)  {    fileInput = std::string( argv[ i ] );    loadFile2( fileInput, v_temp, predicateCPU );    writeVector(v_temp, v_export, i-2);    deleteVector2( v_temp );  }  writeFile( fileOutput, v_export );  deleteVector( v_export );  return 0;}

void CP25Control::createRFHeader(){	unsigned char buffer[P25_HDR_FRAME_LENGTH_BYTES + 2U];	::memset(buffer, 0x00U, P25_HDR_FRAME_LENGTH_BYTES + 2U);	buffer[0U] = TAG_HEADER;	buffer[1U] = 0x00U;	// Add the sync	CSync::addP25Sync(buffer + 2U);	// Add the NID	m_nid.encode(buffer + 2U, P25_DUID_HEADER);	// Add the dummy header	m_rfData.encodeHeader(buffer + 2U);	// Add busy bits	addBusyBits(buffer + 2U, P25_HDR_FRAME_LENGTH_BITS, false, true);	m_rfFrames = 0U;	m_rfErrs = 0U;	m_rfBits = 1U;	m_rfTimeout.start();	m_lastDUID = P25_DUID_HEADER;	::memset(m_rfLDU, 0x00U, P25_LDU_FRAME_LENGTH_BYTES);#if defined(DUMP_P25)	openFile();	writeFile(buffer + 2U, buffer - 2U);#endif	if (m_duplex) {		buffer[0U] = TAG_HEADER;		buffer[1U] = 0x00U;		writeQueueRF(buffer, P25_HDR_FRAME_LENGTH_BYTES + 2U);	}}

void Letterbox::openParticularFile(const QString &filename){	if (!filename.isEmpty())	{		if (m_modified)		{			switch (askToSave())			{				case 0:					writeFile();				case 1:					break;				case 2:					return;			}		}		m_filename = filename;		loadFile();	}}