cách sao chép char * thành chuỗi và ngược lại

Question

Nếu tôi chuyển một char * vào một hàm. Tôi muốn sau đó đi mà char * chuyển đổi nó thành một chuỗi std :: và một khi tôi nhận được kết quả của tôi chuyển đổi nó trở lại char * từ một std :: string để hiển thị kết quả.

1. Tôi không biết làm thế nào để làm điều này cho chuyển đổi (Tôi không nói const char * nhưng chỉ char *)
2. Tôi không chắc chắn làm thế nào để thao tác các giá trị của con trỏ tôi gửi trong.

nên bước tôi cần phải làm

1. mất trong một char *
2. chuyển đổi nó thành một chuỗi.
3. lấy kết quả của chuỗi đó và đặt nó trở lại dưới dạng char *
4. trả về kết quả sao cho giá trị phải có sẵn bên ngoài hàm và không bị hủy.

Nếu có thể, tôi có thể xem cách nó có thể được thực hiện thông qua tham chiếu so với con trỏ (có địa chỉ mà tôi chuyển vào theo giá trị. Tuy nhiên, tôi vẫn có thể sửa đổi giá trị mà con trỏ trỏ tới. địa chỉ trong hàm bị phá hủy tôi vẫn nhìn thấy giá trị thay đổi bên ngoài

nhờ

Answer 1

Chuyển đổi một char* đến một std::string:.!

char* c = "Hello, world"; 
std::string s(c); 

Chuyển đổi một std::string đến một char*:

std::string s = "Hello, world"; 
char* c = new char[s.length() + 1]; 
strcpy(c, s.c_str()); 

// and then later on, when you are done with the `char*`: 
delete[] c; 

Tôi thích sử dụng một std::vector<char> thay vì một thực tế char*; sau đó bạn không cần phải quản lý bộ nhớ của riêng bạn:

std::string s = "Hello, world"; 
std::vector<char> v(s.begin(), s.end()); 
v.push_back('\0'); // Make sure we are null-terminated 
char* c = &v[0]; 

Answer 2

Bạn cần phải xem cách bạn xử lý bộ nhớ từ con trỏ bạn quay trở lại, ví dụ đoạn code dưới đây sẽ không làm việc vì nhớ bố trí trong std: : chuỗi sẽ được giải phóng khi fn() thoát.

const char* fn(const char*psz) { 
    std::string s(psz); 
    // do something with s 
    return s.c_str(); //BAD 
} 

Một giải pháp là phải phân bổ bộ nhớ trong hàm và chắc chắn rằng người gọi của hàm giải phóng nó:

const char* fn(const char*psz) { 
    std::string s(psz); 
    // do something with s 
    char *ret = new char[s.size()]; //memory allocated 
    strcpy(ret, s.c_str()); 
    return ret; 
} 
.... 
const char* p = fn("some text"); 
//do something with p 
delete[] p;// release the array of chars 

Ngoài ra, nếu bạn biết một trên ràng buộc về kích thước của chuỗi bạn có thể tự tạo nó trên ngăn xếp và chuyển vào một con trỏ, ví dụ

void fn(const char*in size_t bufsize, char* out) { 
    std::string s(psz); 
    // do something with s 
    strcpy_s(out, bufsize, s.c_str()); //strcpy_s is a microsoft specific safe str copy 
} 
.... 
const int BUFSIZE = 100; 
char str[BUFSIZE]; 

fn("some text", BUFSIZE, str); 
//ok to use str (memory gets deleted when it goes out of scope) 

Answer 3

Bạn có thể duy trì một bộ thu rác cho thư viện của bạn thực hiện như std::vector<char*> g_gc; có thể truy cập vào thư viện của bạn 'lib'.Sau đó, bạn có thể giải phóng tất cả các con trỏ trong g_gc một cách thuận tiện bằng cách gọi lib::release_garbage();

char* lib::func(char*pStr) 
{ 
    std::string str(pStr); 
    char *outStr = new char[str.size()+1]; 
    strcpy(outStr, str.c_str()); 
    g_gc.push_back(outStr); // collect garbage 
    return outStr; 
} 

chức năng release_garbage sẽ trông giống như:

void lib::release_garbage() 
{ 
    for(int i=0;i<g_gc.size();i++) 
    { 
     delete g_gc[i]; 
    } 
    g_gc.clear(); 
} 

Trong một mô hình luồng duy nhất, bạn có thể giữ này g_gc tĩnh. Mô hình đa luồng sẽ liên quan đến việc khóa/mở khóa nó.