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

int main () {        string s="你好";        wstring ws=L"你好";        cout<<s<<endl;        cout<<wstringtostring(ws)<<endl;        cout<<narrow(ws)<<endl;	wcout.imbue(locale(locale(), "", LC_CTYPE));	// wcout.imbue(locale(""));        // wcout.imbue(locale_platform);        wcout<<ws<<endl;        wcout<<stringtowstring(s)<<endl;        wcout<<widen(s)<<endl;        wofstream fout("fout.txt");        fout.imbue(locale_platform);        fout<<ws<<endl;        fout<<stringtowstring(s)<<endl;        fout<<widen(s)<<endl;	//        string in;//	copy(utf8in(s.begin()), utf8in(s.end()), back_inserter(in));//	cout<<in<<endl;	// copy(utf8in(s.begin()), utf8in(s.end()), back_inserter(wvect));	// cout<<string(utf8in(s.begin()), utf8in(s.end()))<<endl;}

bool init_sentinel() {  // create synchronization event  g_crash_event = CreateEventW(NULL, FALSE, FALSE, widen(crash_id).c_str());  if (!g_crash_event) {    std::cerr << "Could not initialize crash event object." << std::endl;  }  // create shared memory (through MMF)  auto map_file =      CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,                         BUF_SIZE, widen(mmf_name).c_str());  if (!map_file) {    std::cerr << "Could not open MMF (" << crash_id << ")" << std::endl;    std::cerr << "GetLastError(): " << GetLastError() << std::endl;    return false;  }  g_mmf = reinterpret_cast<char *>(      MapViewOfFile(map_file, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE));  // start sentinel.exe  STARTUPINFOW info = {sizeof(info)};  PROCESS_INFORMATION processInfo;  std::stringstream ss;  ss << "sentinel.exe " << crash_id << " " << mmf_name;  if (CreateProcessW(widen("sentinel.exe").c_str(),                     const_cast<wchar_t *>(widen(ss.str()).c_str()), NULL, NULL,                     TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &info,                     &processInfo) == 0) {    return false;  }  SetUnhandledExceptionFilter(unhandled_filter);  return true;}

 StartupInfoEx( LPSTARTUPINFOA si, StringSaver<wchar_t> & s, WideConverter & c ) {     static_cast<STARTUPINFOW &>( *this ) = *reinterpret_cast<LPSTARTUPINFOW>( si );     this->lpReserved = widen( s, c, si->lpReserved );     this->lpDesktop = widen( s, c, si->lpDesktop );     this->lpTitle = widen( s, c, si->lpTitle ); }

void execute_shell(std::string fname, std::string args) {  WCHAR cDir[MAX_PATH];  GetCurrentDirectoryW(MAX_PATH, cDir);  tstring tstr_fname = widen(fname);  tstring tstr_args = widen(args);  ShellExecuteW(enigma::hWnd, NULL, tstr_fname.c_str(), tstr_args.c_str(), cDir, SW_SHOW);}

bool create_snapshot(std::string snapshot_src, std::string snapshot_dst){#ifdef _WIN32	return CopyFolder(widen(snapshot_src), widen(snapshot_dst));#else	int rc=system((btrfs_cmd+" subvolume snapshot /""+snapshot_src+"/" /""+snapshot_dst+"/"").c_str());	system(("chown urbackup:urbackup /""+snapshot_dst+"/"").c_str());	return rc==0;#endif}

intresponse_type7(int id,int major,int minor,int num,char** buf,int bufsize){  canna_server* svr = &server[id];  canna_response_type7 res;  int total,sub,size,offset;  int i;  reset(svr);  if (num == -1) {    res.maj = major;    res.min = minor;    res.size = htons(2);    res.num = htons(-1);    if (emit(svr,&res.maj,1)) return -1;    if (emit(svr,&res.min,1)) return -1;    if (emit(svr,&res.size,2)) return -1;    if (emit(svr,&res.num,2)) return -1;  } else {    total = 0;    for (i = 0; i < bufsize; i++) {      sub = widen(0,0,buf[i],strlen(buf[i])+1);      if (sub == -1) return -1;      total += sub;    }    size = total * 2;    res.maj = major;    res.min = minor;    res.size = htons(2+size);    res.num = htons(num);    res.data = malloc(size);    offset = 0;    for (i = 0; i < bufsize; i++) {      sub = widen(((uint16_t*)res.data) + offset,		  total - offset,buf[i],strlen(buf[i]) + 1);      if (sub == -1) break;      offset += sub;    }    if (emit(svr,&res.maj,1)) return -1;    if (emit(svr,&res.min,1)) return -1;    if (emit(svr,&res.size,2)) return -1;    if (emit(svr,&res.num,2)) return -1;    if (emit(svr,res.data,size)) return -1;    free(res.data);  }  return flush(svr);}

unsigned long long disk_size(std::string drive) {  DWORD sectorsPerCluster, bytesPerSector, totalClusters, freeClusters;  tstring tstr_drive = widen(drive);  tstring tstr_colonslash = widen("://");  tstring tstr_empty = widen("");  if (tstr_drive.length() == 1) tstr_drive += tstr_colonslash;  if (!GetDiskFreeSpaceW((tstr_drive == tstr_empty) ? NULL : tstr_drive.c_str(), &sectorsPerCluster, &bytesPerSector,                         &freeClusters, &totalClusters))    return 0;  return (unsigned long long)(totalClusters * sectorsPerCluster) * (unsigned long long)bytesPerSector;}

	void MidiService::play(string file, int volume)	{		// Предварительно закрываем предыдущий файл.		// В один момент времени может проигрываться только один файл MIDI.		close(true, "");		// Открываем файл.		string command = "open /"" + file + "/" type sequencer alias MidiFile";		wstring wCommand = widen(command);		LPCWSTR pCommand = wCommand.c_str();		MCIERROR err = mciSendString(pCommand, NULL, 0, NULL);		if (err != 0)		{			showError("Не удалось открыть MIDI-файл: " + file);			return;		}		// Запускаем проигрывание.		err = mciSendString(L"play MidiFile from 0", NULL, 0, NULL);		if (err != 0)		{			showError("Не удалось запустить MIDI-файл: " + file);			return;		}		// Устанавливаем громкость проигрываемого файла.		setVolume(volume);		// Сохраняем имя файла.		midiFile = file;	}

std::string environment_get_variable(std::string name) {  WCHAR buffer[1024];  tstring tstr_name = widen(name);  GetEnvironmentVariableW(tstr_name.c_str(), (LPWSTR)&buffer, 1024);  return shorten(buffer);}

Logger &Logger::operator<<(std::string &val)	{#ifndef _SIMPLE_NO_DEBUG	m_stream << widen(val);#endif	return *this;}

bool c_preprocess_none(  const std::string &file,  std::ostream &outstream,  message_handlert &message_handler){  #ifdef _MSC_VER  std::ifstream infile(widen(file).c_str());  #else  std::ifstream infile(file.c_str());  #endif    if(!infile)  {    message_streamt message_stream(message_handler);    message_stream.error("failed to open `"+file+"'");    return true;  }    if(config.ansi_c.mode==configt::ansi_ct::MODE_CODEWARRIOR_C_CPP)  {    // special treatment for "/* #line"    postprocess_codewarrior(infile, outstream);  }  else  {    char ch;    while(infile.read(&ch, 1))      outstream << ch;  }  return false;}

voidbasic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb){  this->rdbuf(__sb);  this->imbue(locale());  this->tie(0);  this->_M_set_exception_mask(ios_base::goodbit);  /*    this->_M_clear_nothrow(__sb != 0 ? ios_base::goodbit : ios_base::badbit);	  The ternary expression above, throws an undefined reference link error (for goodbit and badbit)  when compiled with GCCE 4.3.2. Replacing ternary statement with an if-else block fixes this.  */  if(__sb != 0) {	this->_M_clear_nothrow(ios_base::goodbit);  } else {	this->_M_clear_nothrow(ios_base::badbit);  }  ios_base::flags(ios_base::skipws | ios_base::dec);  ios_base::width(0);  ios_base::precision(6);  this->fill(widen(' '));  // We don't need to worry about any of the three arrays: they are  // initialized correctly in ios_base's constructor.}

void print_response(HttpResponse& response, TcpClientSocket& socket) {	std::cout << narrow(widen(response.getStatusLine(), CP_UTF8), CP_OEMCP) << std::endl;	auto headers = response.getHeaders();	for (auto it = std::begin(headers), eit = std::end(headers); it != eit; ++it) {		for (auto vit = std::begin(it->second), veit = std::end(it->second); vit != veit; ++vit) {			std::cout << it->first << ": " << *vit << std::endl;		}	}	std::cout << "======END OF HEADERS======" << std::endl;	auto& buffer = response.getBuffer();	if (response.getIsChunked()) {		std::cout << "[[CHUNKED ENCODING]]" << std::endl;		for (auto chunk = buffer.getchunk(); !chunk.empty(); chunk = buffer.getchunk()) {			std::cout << chunk;		}		std::cout << "[[TRAILING HEADERS]]" << std::endl;		for (auto th = buffer.getline(); !th.empty(); th = buffer.getline()) {			std::cout << th << std::endl;		}	}	else if (HttpResponse::nlen != response.getContentLength()) {		std::cout << "[[EXACTLY " << response.getContentLength() << " BYTES]]" << std::endl;		std::cout << buffer.getcount(response.getContentLength()) << std::endl;	}	else {		std::vector<BYTE> buff(8 * 1024, 0);		for (auto last = socket.recv_upto(std::begin(buff), std::end(buff));			last != std::begin(buff); last = socket.recv_upto(std::begin(buff), std::end(buff))) {				std::cout << std::string(std::begin(buff), last);		}	}	std::cout << std::endl << "======END OF RESPONSE======" << std::endl;}

bool XmlSettingsStore::Save() {  if (!modified_) {    return true;  }  try {    modified_ = false;    std::ofstream out;    out.open(widen(filename_), std::ios::out | std::ios::trunc);    out << "<?xml version=/"1.0/" encoding=/"UTF-8/" standalone=/"yes/"?>/n";    out << "<settings>/n";    for (const auto& p : long_settings_) {      out << "<long name=/"" << p.first << "/" value=/"" << p.second          << "/"/>/n";    }    for (const auto& p : boolean_settings_) {      std::string value = p.second ? "True" : "False";      out << "<bool name=/"" << p.first << "/" value=/"" << value << "/"/>/n";    }    for (const auto& p : string_settings_) {      std::string attribute = p.second;      XML_Escape(attribute, true /* attribute */);      out << "<string name=/"" << p.first << "/" value=/"" << attribute          << "/"/>/n";    }    out << "</settings>/n";    out.close();  } catch (...) {    // TODO(localize).    m_pMsgs->Message("Failed to save the settings", true /* interrupt */);    return false;  }  return true;}

void WrappedID3D11DeviceContext::AddEvent(D3D11ChunkType type, string description, ResourceId ctx){	if(ctx == ResourceId()) ctx = m_pDevice->GetResourceManager()->GetOriginalID(m_ResourceID);	if(GetType() == D3D11_DEVICE_CONTEXT_DEFERRED)	{		m_pDevice->GetImmediateContext()->AddEvent(type, description, ctx);		return;	}	FetchAPIEvent apievent;	apievent.context = ctx;	apievent.fileOffset = m_CurChunkOffset;	apievent.eventID = m_CurEventID;	apievent.eventDesc = widen(description);	Callstack::Stackwalk *stack = m_pSerialiser->GetLastCallstack();	if(stack)	{		create_array(apievent.callstack, stack->NumLevels());		memcpy(apievent.callstack.elems, stack->GetAddrs(), sizeof(uint64_t)*stack->NumLevels());	}	m_CurEvents.push_back(apievent);	if(m_State == READING)		m_Events.push_back(apievent);}

int directory_exists(std::string dname) {  DWORD file_attr;  tstring tstr_dname = widen(dname);  file_attr = GetFileAttributesW(tstr_dname.c_str());  return (file_attr != INVALID_FILE_ATTRIBUTES &&    (file_attr & FILE_ATTRIBUTE_DIRECTORY));}

	implementation(size_t output_channels, size_t input_channels, size_t output_sample_rate, size_t input_sample_rate, AVSampleFormat output_sample_format, AVSampleFormat input_sample_format)		: output_channels_(output_channels)		, output_sample_format_(output_sample_format)		, input_channels_(input_channels)		, input_sample_format_(input_sample_format)	{		if(input_channels		!= output_channels || 		   input_sample_rate	!= output_sample_rate ||		   input_sample_format	!= output_sample_format)		{				auto resampler = av_audio_resample_init(output_channels,		input_channels,													output_sample_rate,		input_sample_rate,													output_sample_format,	input_sample_format,													16, 10, 0, 0.8);			buffer2_.resize(AVCODEC_MAX_AUDIO_FRAME_SIZE*2);			char sample_fmt_string[200];			av_get_sample_fmt_string(sample_fmt_string, 200, input_sample_format);			CASPAR_LOG(warning) << L"[audio-resampler]"										<< L" sample-rate: "	<< input_sample_rate 								<< L" channels: "		<< input_channels 								<< L" sample-fmt: "		<< widen(sample_fmt_string);			if(resampler)				resampler_.reset(resampler, audio_resample_close);			else				BOOST_THROW_EXCEPTION(caspar_exception());		}			}

bool WrappedOpenGL::Serialise_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil){	SERIALISE_ELEMENT(GLenum, buf, buffer);	SERIALISE_ELEMENT(int32_t, draw, drawbuffer);	SERIALISE_ELEMENT(float, d, depth);	SERIALISE_ELEMENT(int32_t, s, stencil);		if(m_State <= EXECUTING)		m_Real.glClearBufferfi(buf, draw, d, s);		const string desc = m_pSerialiser->GetDebugStr();	if(m_State == READING)	{		AddEvent(CLEARBUFFERFI, desc);		string name = "glClearBufferfi(" +						ToStr::Get(buf) + ", " +						ToStr::Get(draw) + ")";		FetchDrawcall draw;		draw.name = widen(name);		draw.flags |= eDraw_Clear;		AddDrawcall(draw, true);	}	return true;}

ResourceId ReplayRenderer::BuildCustomShader(const wchar_t *entry, const wchar_t *source, const uint32_t compileFlags, ShaderStageType type, rdctype::wstr *errors){	ResourceId id;	string errs;		switch(type)	{		case eShaderStage_Vertex:		case eShaderStage_Hull:		case eShaderStage_Domain:		case eShaderStage_Geometry:		case eShaderStage_Pixel:		case eShaderStage_Compute:			break;		default:			RDCERR("Unexpected type in BuildShader!");			return ResourceId();	}	m_pDevice->BuildCustomShader(narrow(source), narrow(entry), compileFlags, type, &id, &errs);	if(id != ResourceId())		m_CustomShaders.insert(id);		if(errors) *errors = widen(errs);	return id;}

 result_type operator()(From const &from, Traits const &tr) const {     widen_fun<Traits> widen(tr);     To to(         boost::make_transform_iterator(detail::data_begin(from), widen)       , boost::make_transform_iterator(detail::data_end(from), widen)     );     return to; }

bool remove_subvolume(std::string subvolume_folder){#ifdef _WIN32	return os_remove_nonempty_dir(widen(subvolume_folder));#else	int rc=system((btrfs_cmd+" subvolume delete /""+subvolume_folder+"/"").c_str());	return rc==0;#endif}	

 CreateProcessParams( char const * appName, char * commandLine,     LPSECURITY_ATTRIBUTES procAttr, LPSECURITY_ATTRIBUTES threadAttr,     BOOL inherit, DWORD flags, void * env, char const * curDir,     LPSTARTUPINFOA pStartupInfo )     :     stringSaver_( new StringSaver<wchar_t>() ),     lpApplicationName( widen( appName ) ),     lpCommandLine( widen( commandLine ) ),     lpProcessAttributes( procAttr ),     lpThreadAttributes( threadAttr ),     bInheritHandles( inherit ),     dwCreationFlags( flags ),     environment( env, ( flags & CREATE_UNICODE_ENVIRONMENT ) != 0 ),     lpCurrentDirectory( widen( curDir ) ),     startupInfo( pStartupInfo, *stringSaver_, converter_ ) {     postProcessArgs(); }

  void serialize(std::vector<byte> & v) const {    insert_obj(v, sizeof(WORD), _pt_size);    auto font_name = widen(_name);    insert_data(v, 1,                (byte *) font_name.c_str(),                (byte *) (font_name.c_str() +                          font_name.size() + 1));  }

BOOL LASwriterTXT::open(const CHAR* file_name, const LASheader* header, const CHAR* parse_string, const CHAR* separator){  if (file_name == 0)  {    fprintf(stderr,"ERROR: file name pointer is zero/n");    return FALSE;  }  file = fopen(widen(file_name).c_str(), widen("w").c_str());  if (file == 0)  {    fprintf(stderr, "ERROR: cannot open file '%s'/n", file_name);    return FALSE;  }  close_file = TRUE;  return open(file, header, parse_string, separator);}

bool create_snapshot(int mode, std::string snapshot_src, std::string snapshot_dst){#ifdef _WIN32	return CopyFolder(widen(snapshot_src), widen(snapshot_dst));#else	if(mode==mode_btrfs)	{		int rc=exec_wait(find_btrfs_cmd(), true, "subvolume", "snapshot", snapshot_src.c_str(), snapshot_dst.c_str(), NULL);		chown_dir(snapshot_dst);		return rc==0;	}	else if(mode==mode_zfs)	{		zfs_elevate();		int rc=exec_wait(find_zfs_cmd(), true, "clone", (snapshot_src+"@ro").c_str(), snapshot_dst.c_str(), NULL);		chown_dir(snapshot_dst);		return rc==0;	}	return false;#endif}

std::string toUTF8(const std::string& s){#ifndef WT_NO_STD_WSTRING  return toUTF8(widen(s));#else  // You may want to rewrite this for your system  std::string retval = s;  for(std::size_t i = 0; i < retval.size(); ++i)    if (retval[i] > 127) retval[i] = '?';  return s;#endif}

bool set_working_directory(string dname) {  tstring tstr_dname = widen(dname);  replace(tstr_dname.begin(), tstr_dname.end(), '/', '//');  if (SetCurrentDirectoryW(tstr_dname.c_str()) != 0) {    WCHAR wstr_buffer[MAX_PATH + 1];    if (GetCurrentDirectoryW(MAX_PATH + 1, wstr_buffer) != 0) {      working_directory = add_slash(shorten(wstr_buffer));      return true;    }  }  return false;}