Làm cách nào để chuyển std :: string thành chữ thường?

Tôi muốn chuyển đổi một std::stringchữ thường. Tôi nhận thức được chức năng này tolower(), tuy nhiên trong quá khứ tôi đã gặp vấn đề với chức năng này và dù sao nó cũng khó lý tưởng vì sử dụng với std::stringyêu cầu lặp lại qua từng ký tự.

Có một sự thay thế hoạt động 100% thời gian?

Chuyển thể từ những câu hỏi không thường gặp :

#include <algorithm>
#include <cctype>
#include <string>

std::string data = "Abc";
std::transform(data.begin(), data.end(), data.begin(),
    [](unsigned char c){ return std::tolower(c); });

Bạn thực sự sẽ không thoát khỏi mà không lặp qua từng nhân vật. Không có cách nào để biết nhân vật là chữ thường hay chữ hoa.

Nếu bạn thực sự ghét tolower(), đây là một giải pháp thay thế chỉ dành riêng cho ASCII mà tôi không khuyên bạn nên sử dụng:

char asciitolower(char in) {
    if (in <= 'Z' && in >= 'A')
        return in - ('Z' - 'z');
    return in;
}

std::transform(data.begin(), data.end(), data.begin(), asciitolower);

Xin lưu ý rằng tolower()chỉ có thể thực hiện thay thế một ký tự một byte, không phù hợp với nhiều tập lệnh, đặc biệt là nếu sử dụng mã hóa nhiều byte như UTF-8.

Boost cung cấp một thuật toán chuỗi cho việc này :

#include <boost/algorithm/string.hpp>

std::string str = "HELLO, WORLD!";
boost::algorithm::to_lower(str); // modifies str

Hoặc, đối với không tại chỗ :

#include <boost/algorithm/string.hpp>

const std::string str = "HELLO, WORLD!";
const std::string lower_str = boost::algorithm::to_lower_copy(str);

tl; dr

Sử dụng thư viện ICU . Nếu bạn không, thói quen chuyển đổi của bạn sẽ âm thầm phá vỡ các trường hợp mà bạn có thể không biết thậm chí còn tồn tại.

Đầu tiên bạn phải trả lời một câu hỏi: Mã hóa của bạn là std::stringgì? Có phải ISO-8859-1 không? Hoặc có lẽ ISO-8859-8? Hoặc Windows Codepage 1252? Có bất cứ điều gì bạn đang sử dụng để chuyển đổi chữ hoa sang chữ thường không? (Hay nó thất bại thảm hại cho các nhân vật hơn 0x7f?)

Nếu bạn đang sử dụng UTF-8 (sự lựa chọn lành mạnh duy nhất trong số các mã hóa 8 bit) với std::stringdạng container, bạn đã tự lừa dối mình khi tin rằng bạn vẫn đang kiểm soát mọi thứ, bởi vì bạn đang lưu trữ một chuỗi ký tự đa nhân trong một container đó là không nhận thức được khái niệm đa bào. Ngay cả một cái gì đó đơn giản như .substr()là một khung thời gian tích tắc. (Vì việc tách chuỗi đa chuỗi sẽ dẫn đến chuỗi (phụ) không hợp lệ.)

Và ngay khi bạn thử một cái gì đó như std::toupper( 'ß' ), trong bất kỳ mã hóa nào , bạn sẽ gặp rắc rối sâu sắc. (Bởi vì đơn giản là không thể thực hiện "quyền" này với thư viện chuẩn, chỉ có thể cung cấp một ký tự kết quả, không "SS"cần thiết ở đây.) [1] Một ví dụ khác sẽ std::tolower( 'I' )mang lại kết quả khác nhau tùy theo miền địa phương . Ở Đức, 'i'sẽ đúng; ở Thổ Nhĩ Kỳ, 'ı'(LATIN SMALL LETTER DOTLESS I) là kết quả mong đợi (một lần nữa, nhiều hơn một byte trong mã hóa UTF-8). Một ví dụ khác là Sigma Hy Lạp , chữ hoa '∑', chữ thường 'σ'... ngoại trừ ở cuối từ, nó ở đâu 'ς'.

Vì vậy, bất kỳ chuyển đổi trường hợp nào hoạt động trên một ký tự tại một thời điểm, hoặc tệ hơn, một byte tại một thời điểm, đều bị phá vỡ bởi thiết kế.

Sau đó là điểm mà các thư viện chuẩn, cho những gì nó là có khả năng làm, là tùy thuộc vào miền địa phương được hỗ trợ trên máy phần mềm của bạn đang chạy trên ... và bạn sẽ làm gì nếu nó không phải là?

Vì vậy, những gì bạn đang thực sự tìm kiếm là một lớp chuỗi có khả năng xử lý tất cả điều này một cách chính xác, và đó không phải là bất kỳ std::basic_string<>biến thể nào .

(C ++ 11 lưu ý: std::u16stringvà std::u32stringlà tốt hơn ., Nhưng vẫn không hoàn thiện C ++ 20 mang std::u8string, nhưng tất cả những việc phải làm là xác định mã hóa Trong nhiều khía cạnh khác mà họ vẫn không biết gì về cơ khí Unicode, như bình thường, đối chiếu, ... .)

Mặc dù Boost có vẻ đẹp, API thông minh, Boost.Locale về cơ bản là một trình bao bọc xung quanh ICU . Nếu Boost được biên dịch với hỗ trợ ICU ... nếu không, Boost.Locale bị giới hạn ở hỗ trợ ngôn ngữ được biên dịch cho thư viện chuẩn.

Và tin tôi đi, đôi khi việc Boost được biên dịch với ICU có thể là một nỗi đau thực sự. (Không có nhị phân được biên dịch sẵn cho Windows, vì vậy bạn phải cung cấp chúng cùng với ứng dụng của mình và điều đó sẽ mở ra một hộp giun hoàn toàn mới ...)

Vì vậy, cá nhân tôi khuyên bạn nên nhận hỗ trợ Unicode đầy đủ trực tiếp từ miệng ngựa và sử dụng thư viện ICU trực tiếp:

#include <unicode/unistr.h>
#include <unicode/ustream.h>
#include <unicode/locid.h>

#include <iostream>

int main()
{
    /*                          "Odysseus" */
    char const * someString = u8"ΟΔΥΣΣΕΥΣ";
    icu::UnicodeString someUString( someString, "UTF-8" );
    // Setting the locale explicitly here for completeness.
    // Usually you would use the user-specified system locale,
    // which *does* make a difference (see ı vs. i above).
    std::cout << someUString.toLower( "el_GR" ) << "\n";
    std::cout << someUString.toUpper( "el_GR" ) << "\n";
    return 0;
}

Biên dịch (với G ++ trong ví dụ này):

g++ -Wall example.cpp -licuuc -licuio

Điều này mang lại:

ὀδυσσεύς

Lưu ý rằng chuyển đổi Σ <-> in ở giữa từ và chuyển đổi Σ <-> ở cuối từ. Không có <algorithm>giải pháp dựa trên có thể cung cấp cho bạn điều đó.

. ). Ví dụ đẹp của tôi, đã bị lỗi thời bởi quyết định của ủy ban ...

Sử dụng phạm vi dựa trên phạm vi cho vòng lặp của C ++ 11, một mã đơn giản hơn sẽ là:

#include <iostream>       // std::cout
#include <string>         // std::string
#include <locale>         // std::locale, std::tolower

int main ()
{
  std::locale loc;
  std::string str="Test String.\n";

 for(auto elem : str)
    std::cout << std::tolower(elem,loc);
}

Nếu chuỗi chứa các ký tự UTF-8 nằm ngoài phạm vi ASCII, thì boost :: Thuật toán :: to_lower sẽ không chuyển đổi các ký tự đó. Sử dụng tốt hơn boost :: locale :: to_lower khi có UTF-8. Xem http://www.boost.org/doc/libs/1_51_0/libs/locale/doc/html/conversions.html

Đây là phần tiếp theo cho phản hồi của Stefan Mai: nếu bạn muốn đặt kết quả của chuyển đổi trong một chuỗi khác, bạn cần phân bổ trước không gian lưu trữ của nó trước khi gọi std::transform. Vì STL lưu trữ các ký tự được chuyển đổi ở trình lặp đích (tăng nó ở mỗi lần lặp của vòng lặp), chuỗi đích sẽ không được tự động thay đổi kích thước và bạn có nguy cơ dậm bộ nhớ.

#include <string>
#include <algorithm>
#include <iostream>

int main (int argc, char* argv[])
{
  std::string sourceString = "Abc";
  std::string destinationString;

  // Allocate the destination space
  destinationString.resize(sourceString.size());

  // Convert the source string to lower case
  // storing the result in destination string
  std::transform(sourceString.begin(),
                 sourceString.end(),
                 destinationString.begin(),
                 ::tolower);

  // Output the result of the conversion
  std::cout << sourceString
            << " -> "
            << destinationString
            << std::endl;
}

Một cách tiếp cận khác sử dụng phạm vi dựa trên vòng lặp với biến tham chiếu

string test = "Hello World";
for(auto& c : test)
{
   c = tolower(c);
}

cout<<test<<endl;

Theo như tôi thấy các thư viện Boost thực sự kém hiệu năng. Tôi đã thử nghiệm unordered_map của họ với STL và nó chậm hơn trung bình 3 lần (trường hợp tốt nhất 2, tệ nhất là 10 lần). Ngoài ra thuật toán này có vẻ quá thấp.

Sự khác biệt quá lớn đến nỗi tôi chắc chắn rằng bất kỳ sự bổ sung nào bạn sẽ cần phải làm tolowerđể làm cho nó bằng với việc tăng "cho nhu cầu của bạn" sẽ nhanh hơn so với tăng.

Tôi đã thực hiện các thử nghiệm này trên Amazon EC2, do đó hiệu suất thay đổi trong quá trình thử nghiệm nhưng bạn vẫn có ý tưởng.

./test
Elapsed time: 12365milliseconds
Elapsed time: 1640milliseconds
./test
Elapsed time: 26978milliseconds
Elapsed time: 1646milliseconds
./test
Elapsed time: 6957milliseconds
Elapsed time: 1634milliseconds
./test
Elapsed time: 23177milliseconds
Elapsed time: 2421milliseconds
./test
Elapsed time: 17342milliseconds
Elapsed time: 14132milliseconds
./test
Elapsed time: 7355milliseconds
Elapsed time: 1645milliseconds

-O2 làm cho nó như thế này:

./test
Elapsed time: 3769milliseconds
Elapsed time: 565milliseconds
./test
Elapsed time: 3815milliseconds
Elapsed time: 565milliseconds
./test
Elapsed time: 3643milliseconds
Elapsed time: 566milliseconds
./test
Elapsed time: 22018milliseconds
Elapsed time: 566milliseconds
./test
Elapsed time: 3845milliseconds
Elapsed time: 569milliseconds

Nguồn:

string str;
bench.start();
for(long long i=0;i<1000000;i++)
{
    str="DSFZKMdskfdsjfsdfJDASFNSDJFXCKVdnjsafnjsdfjdnjasnJDNASFDJDSFSDNJjdsanjfsdnfjJNFSDJFSD";
    boost::algorithm::to_lower(str);
}
bench.end();

bench.start();
for(long long i=0;i<1000000;i++)
{
    str="DSFZKMdskfdsjfsdfJDASFNSDJFXCKVdnjsafnjsdfjdnjasnJDNASFDJDSFSDNJjdsanjfsdnfjJNFSDJFSD";
    for(unsigned short loop=0;loop < str.size();loop++)
    {
        str[loop]=tolower(str[loop]);
    }
}
bench.end();

Tôi đoán tôi nên thử nghiệm trên một máy chuyên dụng nhưng tôi sẽ sử dụng EC2 này vì vậy tôi không thực sự cần phải thử nghiệm trên máy của mình.

Cách đơn giản nhất để chuyển đổi chuỗi thành loweercase mà không cần bận tâm về không gian tên std như sau

1: chuỗi có / không có dấu cách

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(){
    string str;
    getline(cin,str);
//------------function to convert string into lowercase---------------
    transform(str.begin(), str.end(), str.begin(), ::tolower);
//--------------------------------------------------------------------
    cout<<str;
    return 0;
}

2: chuỗi không có dấu cách

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(){
    string str;
    cin>>str;
//------------function to convert string into lowercase---------------
    transform(str.begin(), str.end(), str.begin(), ::tolower);
//--------------------------------------------------------------------
    cout<<str;
    return 0;
}

std::ctype::tolower()từ thư viện Bản địa hóa C ++ chuẩn sẽ thực hiện chính xác điều này cho bạn. Dưới đây là một ví dụ được trích xuất từ trang tham chiếu khoan dung

#include <locale>
#include <iostream>

int main () {
  std::locale::global(std::locale("en_US.utf8"));
  std::wcout.imbue(std::locale());
  std::wcout << "In US English UTF-8 locale:\n";
  auto& f = std::use_facet<std::ctype<wchar_t>>(std::locale());
  std::wstring str = L"HELLo, wORLD!";
  std::wcout << "Lowercase form of the string '" << str << "' is ";
  f.tolower(&str[0], &str[0] + str.size());
  std::wcout << "'" << str << "'\n";
}

Một thay thế cho Boost là POCO (pocoproject.org).

POCO cung cấp hai biến thể:

1. Biến thể đầu tiên tạo một bản sao mà không thay đổi chuỗi gốc.
2. Biến thể thứ hai thay đổi chuỗi gốc tại chỗ.
   Các phiên bản "In Place" luôn có tên "InPlace".
   

Cả hai phiên bản được trình bày dưới đây:

#include "Poco/String.h"
using namespace Poco;

std::string hello("Stack Overflow!");

// Copies "STACK OVERFLOW!" into 'newString' without altering 'hello.'
std::string newString(toUpper(hello));

// Changes newString in-place to read "stack overflow!"
toLowerInPlace(newString);

Có một cách để chuyển đổi chữ hoa thành chữ thường mà KHÔNG thực hiện nếu kiểm tra , và nó khá đơn giản. Việc sử dụng hàm / macro của isupper () của clocale.h sẽ giải quyết các vấn đề liên quan đến vị trí của bạn, nhưng nếu không, bạn luôn có thể điều chỉnh UtoL [] theo nội dung trái tim của bạn.

Cho rằng các ký tự của C thực sự chỉ là số nguyên 8 bit (bỏ qua các bộ ký tự rộng trong thời điểm này), bạn có thể tạo một mảng 256 byte chứa một bộ ký tự thay thế và trong hàm chuyển đổi sử dụng các ký tự trong chuỗi của bạn làm các ký tự vào mảng chuyển đổi.

Thay vì ánh xạ 1 trên 1, hãy cung cấp cho các thành viên mảng chữ hoa các giá trị int BYTE cho các ký tự chữ thường. Bạn có thể thấy islower () và isupper () hữu ích ở đây.

Mã trông như thế này ...

#include <clocale>
static char UtoL[256];
// ----------------------------------------------------------------------------
void InitUtoLMap()  {
    for (int i = 0; i < sizeof(UtoL); i++)  {
        if (isupper(i)) {
            UtoL[i] = (char)(i + 32);
        }   else    {
            UtoL[i] = i;
        }
    }
}
// ----------------------------------------------------------------------------
char *LowerStr(char *szMyStr) {
    char *p = szMyStr;
    // do conversion in-place so as not to require a destination buffer
    while (*p) {        // szMyStr must be null-terminated
        *p = UtoL[*p];  
        p++;
    }
    return szMyStr;
}
// ----------------------------------------------------------------------------
int main() {
    time_t start;
    char *Lowered, Upper[128];
    InitUtoLMap();
    strcpy(Upper, "Every GOOD boy does FINE!");

    Lowered = LowerStr(Upper);
    return 0;
}

Cách tiếp cận này đồng thời sẽ cho phép bạn sắp xếp lại bất kỳ nhân vật nào khác mà bạn muốn thay đổi.

Cách tiếp cận này có một lợi thế rất lớn khi chạy trên các bộ xử lý hiện đại, không cần phải dự đoán nhánh vì không có nếu các thử nghiệm bao gồm phân nhánh. Điều này giúp tiết kiệm logic dự đoán nhánh của CPU cho các vòng lặp khác và có xu hướng ngăn chặn các quầy hàng đường ống.

Một số người ở đây có thể nhận ra cách tiếp cận này giống như cách tiếp cận được sử dụng để chuyển đổi EBCDIC sang ASCII.

Vì không có câu trả lời nào đề cập đến thư viện Ranges sắp tới, có sẵn trong thư viện tiêu chuẩn kể từ C ++ 20, và hiện có sẵn riêng biệt trên GitHub là range-v3, tôi muốn nói thêm một cách để thực hiện chuyển đổi này sử dụng nó.

Để sửa đổi chuỗi tại chỗ:

str |= action::transform([](unsigned char c){ return std::tolower(c); });

Để tạo một chuỗi mới:

auto new_string = original_string
    | view::transform([](unsigned char c){ return std::tolower(c); });

(Đừng quên #include <cctype>và các tiêu đề Phạm vi yêu cầu.)

Lưu ý: việc sử dụng unsigned charlàm đối số cho lambda được lấy cảm hứng từ cppreference , trong đó nêu rõ:

Giống như tất cả các hàm khác từ <cctype>, hành vi của std::tolowerkhông được xác định nếu giá trị của đối số không thể biểu thị unsigned charbằng hoặc không bằng EOF. Để sử dụng các hàm này một cách an toàn với char( signed charcác) đơn giản, trước tiên, đối số nên được chuyển đổi thành unsigned char:

char my_tolower(char ch)
{
    return static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
}

Tương tự, chúng không nên được sử dụng trực tiếp với các thuật toán tiêu chuẩn khi loại giá trị của trình lặp là charhoặc signed char. Thay vào đó, chuyển đổi giá trị thành unsigned charđầu tiên:

std::string str_tolower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), 
                // static_cast<int(*)(int)>(std::tolower)         // wrong
                // [](int c){ return std::tolower(c); }           // wrong
                // [](char c){ return std::tolower(c); }          // wrong
                   [](unsigned char c){ return std::tolower(c); } // correct
                  );
    return s;
}

Các hàm mẫu của riêng tôi thực hiện chữ hoa / chữ thường.

#include <string>
#include <algorithm>

//
//  Lowercases string
//
template <typename T>
std::basic_string<T> lowercase(const std::basic_string<T>& s)
{
    std::basic_string<T> s2 = s;
    std::transform(s2.begin(), s2.end(), s2.begin(), tolower);
    return std::move(s2);
}

//
// Uppercases string
//
template <typename T>
std::basic_string<T> uppercase(const std::basic_string<T>& s)
{
    std::basic_string<T> s2 = s;
    std::transform(s2.begin(), s2.end(), s2.begin(), toupper);
    return std::move(s2);
}

Đây là một kỹ thuật vĩ mô nếu bạn muốn một cái gì đó đơn giản:

#define STRTOLOWER(x) std::transform (x.begin(), x.end(), x.begin(), ::tolower)
#define STRTOUPPER(x) std::transform (x.begin(), x.end(), x.begin(), ::toupper)
#define STRTOUCFIRST(x) std::transform (x.begin(), x.begin()+1, x.begin(),  ::toupper); std::transform (x.begin()+1, x.end(),   x.begin()+1,::tolower)

Tuy nhiên, lưu ý rằng nhận xét của @ AndreasSpindler về câu trả lời này vẫn là một sự cân nhắc quan trọng, tuy nhiên, nếu bạn đang làm việc trên một cái gì đó không chỉ là các ký tự ASCII.

// tolower example (C++)
#include <iostream>       // std::cout
#include <string>         // std::string
#include <locale>         // std::locale, std::tolower

int main ()
{
  std::locale loc;
  std::string str="Test String.\n";
  for (std::string::size_type i=0; i<str.length(); ++i)
    std::cout << std::tolower(str[i],loc);
  return 0;
}

Để biết thêm thông tin: http://www.cplusplus.com/reference/locale/tolower/

Có một sự thay thế hoạt động 100% thời gian?

Không

Có một số câu hỏi bạn cần phải tự hỏi mình trước khi chọn một phương pháp hạ thấp.

1. Chuỗi được mã hóa như thế nào? ASCII đơn giản? UTF-8? một số hình thức mã hóa di sản ASCII mở rộng?
2. Bạn có ý nghĩa gì bởi chữ thường? Quy tắc ánh xạ trường hợp khác nhau giữa các ngôn ngữ! Bạn có muốn một cái gì đó được bản địa hóa cho miền địa phương người dùng? Bạn có muốn một cái gì đó hoạt động nhất quán trên tất cả các hệ thống mà phần mềm của bạn chạy không? Bạn chỉ muốn viết thường các ký tự ASCII và vượt qua mọi thứ khác?
3. Những thư viện nào có sẵn?

Một khi bạn có câu trả lời cho những câu hỏi đó, bạn có thể bắt đầu tìm kiếm một giải pháp phù hợp với nhu cầu của bạn. Không có một kích thước phù hợp với tất cả mọi thứ hoạt động cho tất cả mọi người ở khắp mọi nơi!

Hãy thử chức năng này :)

string toLowerCase(string str) {
    int str_len = str.length();
    string final_str = "";
    for(int i=0; i<str_len; i++) {
        char character = str[i];
        if(character>=65 && character<=92) {
            final_str += (character+32);
        } else {
            final_str += character;
        }
    }
    return final_str;
}

Trên các nền tảng microsoft, bạn có thể sử dụng nhóm strlwrchức năng: http://msdn.microsoft.com/en-us/l Library / hkxwh33z.aspx

// crt_strlwr.c
// compile with: /W3
// This program uses _strlwr and _strupr to create
// uppercase and lowercase copies of a mixed-case string.
#include <string.h>
#include <stdio.h>

int main( void )
{
   char string[100] = "The String to End All Strings!";
   char * copy1 = _strdup( string ); // make two copies
   char * copy2 = _strdup( string );

   _strlwr( copy1 ); // C4996
   _strupr( copy2 ); // C4996

   printf( "Mixed: %s\n", string );
   printf( "Lower: %s\n", copy1 );
   printf( "Upper: %s\n", copy2 );

   free( copy1 );
   free( copy2 );
}

Đoạn mã

#include<bits/stdc++.h>
using namespace std;


int main ()
{
    ios::sync_with_stdio(false);

    string str="String Convert\n";

    for(int i=0; i<str.size(); i++)
    {
      str[i] = tolower(str[i]);
    }
    cout<<str<<endl;

    return 0;
}

Sử dụng fplus :: to_lower_case ().

(fplus: https://github.com/Dobiasd/FeftalPlus .

Tìm kiếm 'to_lower_case' trong http://www.editgym.com/fplus-api-search/ )

fplus::to_lower_case(std::string("ABC")) == std::string("abc");

Sao chép vì nó không được phép cải thiện câu trả lời. Cảm ơn

string test = "Hello World";
for(auto& c : test)
{
   c = tolower(c);
}

Giải trình:

for(auto& c : test)là một phạm vi dựa trên vòng lặp của loại :
for (range_declaration:range_expression)loop_statement

1. range_declaration: auto& c
   Ở đây bộ xác định tự động được sử dụng để khấu trừ loại tự động. Vì vậy, loại được khấu trừ từ bộ khởi tạo biến.

2. range_expression: test
   Phạm vi trong trường hợp này là các ký tự của chuỗi test.

Các ký tự của chuỗi testcó sẵn như là một tham chiếu bên trong vòng lặp for thông qua định danh c.

C ++ không có các phương thức khoan dung hoặc toupper được triển khai cho chuỗi, nhưng nó có sẵn cho char. Người ta có thể dễ dàng đọc từng char của chuỗi, chuyển đổi nó thành trường hợp cần thiết và đặt lại thành chuỗi. Mã mẫu mà không sử dụng bất kỳ thư viện bên thứ ba nào:

#include<iostream>

int main(){
  std::string str = std::string("How IS The Josh");
  for(char &ch : str){
    ch = std::tolower(ch);
  }
  std::cout<<str<<std::endl;
  return 0;
}

Đối với hoạt động dựa trên ký tự trên chuỗi: Đối với mỗi ký tự trong chuỗi

Đây có thể là một phiên bản đơn giản khác để chuyển đổi chữ hoa thành chữ thường và ngược lại. Tôi đã sử dụng phiên bản cộng đồng VS2017 để biên dịch mã nguồn này.

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

int main()
{
    std::string _input = "lowercasetouppercase";
#if 0
    // My idea is to use the ascii value to convert
    char upperA = 'A';
    char lowerA = 'a';

    cout << (int)upperA << endl; // ASCII value of 'A' -> 65
    cout << (int)lowerA << endl; // ASCII value of 'a' -> 97
    // 97-65 = 32; // Difference of ASCII value of upper and lower a
#endif // 0

    cout << "Input String = " << _input.c_str() << endl;
    for (int i = 0; i < _input.length(); ++i)
    {
        _input[i] -= 32; // To convert lower to upper
#if 0
        _input[i] += 32; // To convert upper to lower
#endif // 0
    }
    cout << "Output String = " << _input.c_str() << endl;

    return 0;
}

Lưu ý: nếu có các ký tự đặc biệt thì cần phải xử lý bằng cách sử dụng kiểm tra điều kiện.

Tôi đã thử std :: Transform, tất cả những gì tôi nhận được là lỗi biên dịch stl criptic đáng ghê tởm mà chỉ có druids từ 200 năm trước mới có thể hiểu được (không thể chuyển đổi từ cúm flibidi flabidi)

cái này hoạt động tốt và có thể dễ dàng điều chỉnh

string LowerCase(string s)
{
    int dif='a'-'A';
    for(int i=0;i<s.length();i++)
    {
        if((s[i]>='A')&&(s[i]<='Z'))
            s[i]+=dif;
    }
   return s;
}

string UpperCase(string s)
{
   int dif='a'-'A';
    for(int i=0;i<s.length();i++)
    {
        if((s[i]>='a')&&(s[i]<='z'))
            s[i]-=dif;
    }
   return s;
}