ฉันมีชั้นเรียนด้วย private char str[256];

และสำหรับฉันมีตัวสร้างที่ชัดเจน:

explicit myClass(const char *func)
{
    strcpy(str,func);
}

ฉันเรียกมันว่า:

myClass obj("example");

เมื่อฉันรวบรวมสิ่งนี้ฉันจะได้รับคำเตือนต่อไปนี้:

การแปลงที่เลิกใช้แล้วจากค่าคงที่สตริงเป็น 'char *'

ทำไมสิ่งนี้จึงเกิดขึ้น

นี่คือข้อความแสดงข้อผิดพลาดที่คุณเห็นเมื่อใดก็ตามที่คุณมีสถานการณ์เช่นนี้:

char* pointer_to_nonconst = "string literal";

ทำไม? ดี C และ C ++ แตกต่างกันในประเภทของตัวอักษรสตริง ใน C ประเภทคืออาร์เรย์ของถ่านและใน C ++ มันเป็นอาร์เรย์คงที่ของถ่าน ไม่ว่าในกรณีใดคุณไม่ได้รับอนุญาตให้เปลี่ยนอักขระของตัวอักษรสตริงดังนั้น const ใน C ++ จึงไม่ใช่ข้อ จำกัด จริงๆ แต่เป็นประเภทความปลอดภัยที่มากกว่า การแปลงจากconst char*ไปchar*โดยทั่วไปไม่ได้โดยไม่ต้องหล่อที่ชัดเจนสำหรับเหตุผลด้านความปลอดภัย แต่สำหรับความเข้ากันได้ย้อนหลังกับ C ภาษา C ++ ยังคงอนุญาตให้กำหนดสตริงตัวอักษรให้กับchar*และให้คำเตือนเกี่ยวกับการแปลงนี้จะถูกคัดค้าน

ดังนั้นบางที่คุณขาดหายไปอย่างน้อยหนึ่งตัวconstในโปรแกรมเพื่อความถูกต้องของ const แต่รหัสที่คุณแสดงให้เรานั้นไม่ใช่ปัญหาเพราะมันไม่ได้ทำการแปลงที่เลิกใช้แล้ว คำเตือนต้องมาจากที่อื่น

คำเตือน:

การแปลงที่เลิกใช้แล้วจากค่าคงที่สตริงเป็น 'char *'

ได้รับเนื่องจากคุณกำลังทำบางแห่ง (ไม่ใช่ในรหัสที่คุณโพสต์) บางสิ่งเช่น:

void foo(char* str);
foo("hello");

ปัญหาคือว่าคุณกำลังพยายามที่จะแปลงตัวอักษรสตริง (กับชนิดconst char[]) char*เพื่อ

คุณสามารถแปลงconst char[]ไปconst char*เพราะอาร์เรย์สูญสลายตัวชี้ แต่สิ่งที่คุณกำลังทำคือการทำอย่างต่อเนื่องแน่นอน

การแปลงนี้อาจได้รับอนุญาตสำหรับการทำงานร่วมกันของ C และเพียงแค่แจ้งเตือนให้คุณทราบ

ในฐานะที่เป็นคำตอบที่ไม่มี 2 โดย fnieto - Fernando Nietoอธิบายอย่างชัดเจนและถูกต้องว่ามีการแจ้งเตือนนี้เนื่องจากมีบางอย่างในรหัสของคุณที่คุณกำลังทำ (ไม่ใช่ในรหัสที่คุณโพสต์) สิ่งที่ต้องการ:

void foo(char* str);
foo("hello");

อย่างไรก็ตามหากคุณต้องการให้รหัสของคุณไม่มีการเตือนอีกให้ทำการเปลี่ยนแปลงรหัสของคุณตามลำดับ:

void foo(char* str);
foo((char *)"hello");

นั่นคือเพียงแค่โยนอย่างต่อเนื่องเพื่อstring(char *)

มี 3 วิธีคือ:

โซลูชันที่ 1:

const char *x = "foo bar";

โซลูชันที่ 2:

char *x = (char *)"foo bar";

โซลูชันที่ 3:

char* x = (char*) malloc(strlen("foo bar")+1); // +1 for the terminator
strcpy(x,"foo bar");

อาร์เรย์ยังสามารถใช้แทนตัวชี้ได้เนื่องจากอาร์เรย์เป็นตัวชี้ค่าคงที่แล้ว

ในความเป็นจริงสตริงคงที่ตัวอักษรไม่ใช่ const char * หรือ char * แต่เป็น char [] มันค่อนข้างแปลก แต่เขียนลงในสเปค c ++; หากคุณปรับเปลี่ยนพฤติกรรมจะไม่ได้กำหนดเนื่องจากคอมไพเลอร์อาจเก็บไว้ในส่วนรหัส

บางทีคุณสามารถลองสิ่งนี้:

void foo(const char* str) 
{
    // Do something
}

foo("Hello")

มันใช้งานได้สำหรับฉัน

ฉันแก้ปัญหานี้ด้วยการเพิ่มมาโครนี้ในส่วนเริ่มต้นของรหัสที่ไหนสักแห่ง หรือเพิ่มเข้าไป<iostream>ฮิฮิ

 #define C_TEXT( text ) ((char*)std::string( text ).c_str())

เหตุผลสำหรับปัญหานี้ (ซึ่งก็ยากที่จะตรวจสอบกว่าปัญหาด้วยchar* str = "some string"- ซึ่งคนอื่น ๆ ได้อธิบาย) constexprคือเมื่อคุณกำลังใช้

constexpr char* str = "some string";

ดูเหมือนว่ามันจะมีลักษณะการทำงานคล้ายกับconst char* strและจะไม่ก่อให้เกิดคำเตือนที่มันเกิดขึ้นก่อนแต่แทนที่จะทำงานเป็นchar*char* const str

รายละเอียด

ตัวชี้ค่าคงที่และตัวชี้ไปยังค่าคงที่ ความแตกต่างระหว่างconst char* strและchar* const strสามารถอธิบายได้ดังนี้

1. const char* str: ประกาศ str เป็นตัวชี้ไปยัง const char ซึ่งหมายความว่าข้อมูลที่ตัวชี้นี้ชี้ไปยังค่าคงที่ ตัวชี้สามารถแก้ไขได้ แต่ความพยายามใด ๆ ในการปรับเปลี่ยนข้อมูลจะทำให้เกิดข้อผิดพลาดในการรวบรวม
   1. str++ ;: ถูกต้อง เรากำลังแก้ไขตัวชี้ไม่ใช่ข้อมูลที่ชี้ไป
   2. *str = 'a';: ไม่ถูกต้อง เราพยายามแก้ไขข้อมูลที่ชี้ไป
2. char* const str: ประกาศ str เพื่อเป็นตัวชี้ const เพื่อ char ซึ่งหมายความว่าตอนนี้จุดนั้นคงที่ แต่ข้อมูลที่ชี้ไปนั้นไม่ได้เป็นเช่นนั้น ตัวชี้ไม่สามารถแก้ไขได้ แต่เราสามารถแก้ไขข้อมูลโดยใช้ตัวชี้
   1. str++ ;: ไม่ถูกต้องไม่ถูกต้องเราพยายามแก้ไขตัวแปรพอยน์เตอร์ซึ่งเป็นค่าคงที่
   2. *str = 'a';: ถูกต้อง เราพยายามแก้ไขข้อมูลที่ชี้ไป ในกรณีของเราสิ่งนี้จะไม่ทำให้เกิดข้อผิดพลาดในการคอมไพล์ แต่จะทำให้เกิดข้อผิดพลาดรันไทม์เนื่องจากสตริงส่วนใหญ่จะเข้าสู่ส่วนอ่านอย่างเดียวของไบนารีที่คอมไพล์แล้ว คำสั่งนี้จะสมเหตุสมผลถ้าเรามีการจัดสรรหน่วยความจำแบบไดนามิกเช่น char* const str = new char[5];.
3. const char* const str: ประกาศ str เป็นตัวชี้ const ถึง const char ในกรณีนี้เราไม่สามารถแก้ไขตัวชี้หรือข้อมูลที่ชี้ไป
   1. str++ ;: ไม่ถูกต้อง เราพยายามแก้ไขตัวแปรพอยน์เตอร์ซึ่งเป็นค่าคงที่
   2. *str = 'a';: ไม่ถูกต้อง เรากำลังพยายามแก้ไขข้อมูลที่ชี้โดยตัวชี้นี้ซึ่งเป็นค่าคงที่

ในกรณีของฉันปัญหาคือว่าฉันคาดหวังว่าconstexpr char* strจะทำตัวเป็นconst char* strและไม่ได้char* const strเพราะตั้งแต่มองเห็นมันดูเหมือนจะใกล้ชิดกับอดีต

นอกจากนี้ยังมีคำเตือนที่สร้างขึ้นสำหรับเป็นที่แตกต่างกันเล็กน้อยจากconstexpr char* str = "some string"char* str = "some string"

1. คอมไพเลอร์คำเตือนสำหรับconstexpr char* str = "some string":ISO C++11 does not allow conversion from string literal to 'char *const'
2. คอมไพเลอร์คำเตือนสำหรับchar* str = "some string": ISO C++11 does not allow conversion from string literal to 'char *'.

ปลาย

คุณสามารถใช้C ซึ่งพูดพล่อยๆ↔ตัวแปลงภาษาอังกฤษเพื่อแปลงCการประกาศเป็นภาษาอังกฤษที่เข้าใจได้ง่ายและในทางกลับกัน นี้เป็นCเครื่องมือเท่านั้นและสิ่งสนับสนุนเคยชินจึง (เช่น constexpr) C++ซึ่งเป็นเอกสิทธิ์เฉพาะบุคคล

ฉันยังได้รับปัญหาเดียวกัน และสิ่งที่ฉันทำง่ายๆคือแค่เพิ่ม const char * แทนที่จะเป็น char * และปัญหาได้รับการแก้ไข ตามที่คนอื่น ๆ ได้กล่าวไว้ข้างต้นมันเป็นข้อผิดพลาดที่เข้ากันได้ C ถือว่าสตริงเป็นถ่านอาร์เรย์ในขณะที่ C ++ ถือว่าเป็นถ่านอาร์เรย์

สำหรับสิ่งที่คุ้มค่าฉันพบชั้น wrapper ง่าย ๆ นี้จะเป็นประโยชน์สำหรับการแปลงสตริง C ++ เป็นchar *:

class StringWrapper {
    std::vector<char> vec;
public:
    StringWrapper(const std::string &str) : vec(str.begin(), str.end()) {
    }

    char *getChars() {
        return &vec[0];
    }
};

ต่อไปนี้แสดงวิธีแก้ปัญหากำหนดสตริงของคุณให้กับตัวชี้ตัวแปรไปยังอาร์เรย์คงที่ของอักขระถ่าน (สตริงเป็นตัวชี้คงที่ไปยังอาร์เรย์คงที่ของอักขระถ่าน - บวกข้อมูลความยาว):

#include <iostream>

void Swap(const char * & left, const char * & right) {
    const char *const temp = left;
    left = right;
    right = temp;
}

int main() {
    const char * x = "Hello"; // These works because you are making a variable
    const char * y = "World"; // pointer to a constant string
    std::cout << "x = " << x << ", y = " << y << '\n';
    Swap(x, y);
    std::cout << "x = " << x << ", y = " << y << '\n';
}