Saya baru mengenal pemrograman Windows dan setelah membaca buku Petzold saya bertanya-tanya:

apakah masih merupakan praktik yang baik untuk menggunakan TCHARtipe dan _T()fungsi untuk mendeklarasikan string atau jika saya harus menggunakan wchar_tdan L""string dalam kode baru?

Saya hanya akan menargetkan Windows 2000 dan yang lebih baru dan kode saya akan menjadi i18n sejak awal.

Saya masih akan menggunakan sintaks TCHAR jika saya melakukan proyek baru hari ini. Tidak banyak perbedaan praktis antara menggunakannya dan sintaks WCHAR, dan saya lebih suka kode yang eksplisit dalam jenis karakternya. Karena sebagian besar fungsi API dan objek pembantu mengambil / menggunakan tipe TCHAR (misalnya: CString), maka masuk akal untuk menggunakannya. Selain itu, ini memberi Anda fleksibilitas jika Anda memutuskan untuk menggunakan kode dalam aplikasi ASCII di beberapa titik, atau jika Windows pernah berevolusi ke Unicode32, dll.

Jika Anda memutuskan untuk menggunakan rute WCHAR, saya akan menjelaskannya secara eksplisit. Artinya, gunakan CStringW sebagai ganti CString, dan transmisikan makro saat mengonversi ke TCHAR (misalnya: CW2CT).

Itu pendapat saya.

Jawaban singkatnya: TIDAK .

Seperti semua yang sudah ditulis, banyak programmer masih menggunakan TCHAR dan fungsi yang sesuai. Menurut pendapat saya , seluruh konsep adalah ide yang buruk . Pemrosesan string UTF-16 jauh berbeda dari pemrosesan string ASCII / MBCS sederhana. Jika Anda menggunakan algoritme / fungsi yang sama dengan keduanya (inilah yang menjadi dasar ide TCHAR!), Anda mendapatkan kinerja yang sangat buruk pada versi UTF-16 jika Anda melakukan sedikit lebih banyak daripada penggabungan string sederhana (seperti parsing dll.). Alasan utamanya adalah Pengganti .

Dengan satu-satunya pengecualian ketika Anda benar - benar harus mengkompilasi aplikasi Anda untuk sistem yang tidak mendukung Unicode, saya tidak melihat alasan untuk menggunakan bagasi ini dari masa lalu di aplikasi baru.

Saya harus setuju dengan Sascha. Premis yang mendasari TCHAR/_T() / etc. adalah Anda dapat menulis aplikasi berbasis "ANSI" dan kemudian secara ajaib memberinya dukungan Unicode dengan mendefinisikan makro. Tetapi ini didasarkan pada beberapa asumsi buruk:

Bahwa Anda secara aktif membangun versi MBCS dan Unicode dari perangkat lunak Anda

Jika tidak, Anda akan tergelincir dan menggunakan biasachar* string di banyak tempat.

Bahwa Anda tidak menggunakan pelolosan garis miring terbalik non-ASCII dalam literal _T ("...")

Kecuali pengkodean "ANSI" Anda kebetulan ISO-8859-1, hasil char*dan wchar_t*literal tidak akan mewakili karakter yang sama.

String UTF-16 tersebut digunakan seperti string "ANSI"

Mereka tidak. Unicode memperkenalkan beberapa konsep yang tidak ada di sebagian besar pengkodean karakter lama. Pengganti. Menggabungkan karakter. Normalisasi. Aturan kapitalisasi bersyarat dan peka bahasa.

Dan mungkin yang paling penting, fakta bahwa UTF-16 jarang disimpan di disk atau dikirim melalui Internet: UTF-8 cenderung lebih disukai untuk representasi eksternal.

Bahwa aplikasi Anda tidak menggunakan Internet

(Sekarang, ini mungkin asumsi yang valid untuk Anda perangkat lunak , tetapi ...)

Web berjalan pada UTF-8 dan sejumlah besar pengkodean yang lebih jarang . The TCHARKonsep hanya mengakui dua: "ANSI" (yang tidak bisa menjadi UTF-8 ) dan "Unicode" (UTF-16). Ini mungkin berguna untuk membuat panggilan Windows API Anda sadar-Unicode, tetapi itu sangat tidak berguna untuk membuat aplikasi web dan email Anda sadar-Unicode.

Bahwa Anda tidak menggunakan perpustakaan non-Microsoft

Tidak ada orang lain yang menggunakan TCHAR. Poco menggunakan std::stringdan UTF-8. SQLite memiliki API versi UTF-8 dan UTF-16, tetapi tidak TCHAR. TCHARbahkan tidak ada di pustaka standar, jadi tidak, std::tcoutkecuali Anda ingin mendefinisikannya sendiri.

Yang saya rekomendasikan, bukan TCHAR

Lupakan bahwa pengkodean "ANSI" ada, kecuali saat Anda perlu membaca file yang bukan UTF-8 yang valid. Lupakan TCHARjuga. Selalu panggil fungsi Windows API versi "W". #define _UNICODEhanya untuk memastikan Anda tidak memanggil fungsi "A" secara tidak sengaja.

Selalu gunakan encoding UTF untuk string: UTF-8 untuk charstring dan UTF-16 (di Windows) atau UTF-32 (pada sistem mirip Unix) untuk wchar_tstring. typedef UTF16dan UTF32tipe karakter untuk menghindari perbedaan platform.

Jika Anda bertanya-tanya apakah itu masih dalam praktik, maka ya - itu masih digunakan cukup banyak. Tidak ada yang akan melihat kode Anda lucu jika menggunakan TCHAR dan _T (""). Proyek yang saya kerjakan sekarang sedang mengubah dari ANSI ke unicode - dan kami akan menggunakan rute portabel (TCHAR).

Namun...

Pilihan saya adalah melupakan semua makro portabel ANSI / UNICODE (TCHAR, _T (""), dan semua panggilan _tXXXXXX, dll ...) dan menganggap unicode di mana-mana. Saya benar-benar tidak melihat gunanya menjadi portabel jika Anda tidak akan membutuhkan versi ANSI. Saya akan menggunakan semua fungsi dan tipe karakter lebar secara langsung. Preprend semua string literal dengan L.

Artikel Pengantar Pemrograman Windows di MSDN mengatakan

Aplikasi baru harus selalu memanggil versi Unicode (dari API).

The TEXT dan TCHAR macro kurang berguna hari ini, karena semua aplikasi harus menggunakan Unicode.

Saya akan tetap berpegang pada wchar_tdan L"".

Saya ingin menyarankan pendekatan yang berbeda (tidak satu pun dari keduanya).

Untuk meringkas, gunakan char * dan std :: string, dengan asumsi encoding UTF-8, dan lakukan konversi ke UTF-16 hanya saat menggabungkan fungsi API.

Informasi lebih lanjut dan justifikasi untuk pendekatan ini dalam program Windows dapat ditemukan di http://www.utf8everywhere.org .

TCHARSaya WCHARmungkin cukup untuk beberapa proyek lama. Tetapi untuk aplikasi baru, saya akan mengatakan TIDAK .

Semua ini TCHAR/ WCHARbarang ada karena alasan sejarah. TCHARmenyediakan cara yang tampaknya rapi (menyamar) untuk beralih antara pengkodean teks ANSI (MBCS) dan pengkodean teks Unicode (UTF-16). Dahulu, orang tidak memiliki pemahaman tentang jumlah karakter dari semua bahasa di dunia. Mereka mengasumsikan 2 byte cukup untuk mewakili semua karakter dan dengan demikian memiliki skema pengkodean karakter dengan panjang tetap yang digunakan WCHAR. Namun, ini tidak lagi benar setelah rilis Unicode 2.0 pada tahun 1996 .

Artinya: Apa pun yang Anda gunakan di CHAR/ WCHAR/ TCHAR, bagian pemrosesan teks dalam program Anda harus dapat menangani karakter dengan panjang variabel untuk internasionalisasi.

Jadi, Anda sebenarnya perlu melakukan lebih dari sekadar memilih satu dari CHAR/ WCHAR/ TCHARuntuk pemrograman di Windows:

1. Jika aplikasi Anda kecil dan tidak melibatkan pemrosesan teks (yaitu, hanya meneruskan string teks sebagai argumen), maka tetap gunakan WCHAR . Karena cara ini lebih mudah untuk bekerja dengan WinAPI dengan dukungan Unicode.
2. Jika tidak, saya akan menyarankan menggunakan UTF-8 sebagai pengkodean internal dan menyimpan teks dalam string char atau std :: string. Dan sembunyikan mereka ke UTF-16 saat memanggil WinAPI. UTF-8 sekarang menjadi pengkodean yang dominan dan ada banyak pustaka dan alat praktis untuk memproses string UTF-8.

Lihat situs web yang luar biasa ini untuk bacaan yang lebih mendalam: http://utf8everywhere.org/

Ya, tentu saja; setidaknya untuk makro _T. Saya tidak begitu yakin tentang hal-hal yang berkarakter luas.

Alasannya adalah untuk lebih mendukung WinCE atau platform Windows non-standar lainnya. Jika Anda 100% yakin bahwa kode Anda akan tetap di NT, maka Anda mungkin bisa menggunakan deklarasi C-string biasa. Namun, yang terbaik adalah cenderung ke pendekatan yang lebih fleksibel, karena jauh lebih mudah untuk #menentukan makro itu di platform non-windows dibandingkan dengan menelusuri ribuan baris kode dan menambahkannya di mana-mana jika Anda perlu mem-port beberapa pustaka ke windows mobile.

IMHO, jika ada TCHAR dalam kode Anda, Anda bekerja di tingkat abstraksi yang salah.

Gunakan jenis string apa pun yang paling nyaman bagi Anda saat berurusan dengan pemrosesan teks - semoga ini akan menjadi sesuatu yang mendukung unicode, tetapi itu terserah Anda. Lakukan konversi pada batasan OS API seperlunya.

Saat berurusan dengan jalur file, siapkan jenis kustom Anda sendiri daripada menggunakan string. Ini akan memungkinkan Anda pemisah jalur OS-independen, akan memberi Anda antarmuka yang lebih mudah untuk kode daripada penggabungan dan pemisahan string manual, dan akan jauh lebih mudah untuk beradaptasi dengan OS yang berbeda (ansi, ucs-2, utf-8, apa pun) .

Satu-satunya alasan saya melihat untuk menggunakan apa pun selain WCHAR eksplisit adalah portabilitas dan efisiensi.

Jika Anda ingin membuat eksekusi akhir Anda sekecil mungkin, gunakan char.

Jika Anda tidak peduli tentang penggunaan RAM dan ingin internasionalisasi menjadi semudah terjemahan sederhana, gunakan WCHAR.

Jika Anda ingin membuat kode Anda fleksibel, gunakan TCHAR.

Jika Anda hanya berencana menggunakan karakter Latin, Anda sebaiknya menggunakan string ASCII / MBCS sehingga pengguna Anda tidak membutuhkan banyak RAM.

Untuk orang yang "i18n dari awal", hemat ruang kode sumber dan cukup gunakan semua fungsi Unicode.

Hanya menambahkan ke pertanyaan lama:

TIDAK

Mulailah proyek CLR C ++ baru di VS2010. Microsoft sendiri menggunakan L"Hello World", 'kata nuff.

TCHARmemiliki arti baru untuk port dari WCHARke CHAR.

https://docs.microsoft.com/en-us/windows/uwp/design/globalizing/use-utf8-code-page

Rilis terbaru Windows 10 telah menggunakan halaman kode ANSI dan -A API sebagai sarana untuk memperkenalkan dukungan UTF-8 ke aplikasi. Jika halaman kode ANSI dikonfigurasi untuk UTF-8, -A API beroperasi di UTF-8.