ความแตกต่างระหว่างประเภทสตริงและ char [] ใน C ++

ฉันรู้ C นิดหน่อยและตอนนี้ฉันกำลังดู C ++ ฉันเคยใช้ถ่านอาร์เรย์สำหรับจัดการกับสตริง C แต่ในขณะที่ฉันดูรหัส C ++ ฉันเห็นมีตัวอย่างที่ใช้ทั้งประเภทสตริงและอาร์เรย์ถ่าน:

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

int main () {
  string mystr;
  cout << "What's your name? ";
  getline (cin, mystr);
  cout << "Hello " << mystr << ".\n";
  cout << "What is your favorite team? ";
  getline (cin, mystr);
  cout << "I like " << mystr << " too!\n";
  return 0;
}

และ

#include <iostream>
using namespace std;

int main () {
  char name[256], title[256];

  cout << "Enter your name: ";
  cin.getline (name,256);

  cout << "Enter your favourite movie: ";
  cin.getline (title,256);

  cout << name << "'s favourite movie is " << title;

  return 0;
}

(ทั้งสองตัวอย่างจากhttp://www.cplusplus.com )

ฉันคิดว่านี่เป็นคำถามที่ถามและตอบกันอย่างแพร่หลาย (ชัดเจน?) แต่จะดีถ้ามีคนบอกฉันได้ว่าอะไรคือความแตกต่างระหว่างสองวิธีในการจัดการกับสตริงใน C ++ (ประสิทธิภาพการรวม API วิธีที่แต่ละคนเป็น ดีกว่า, ... ).

ขอบคุณ.

อาร์เรย์ถ่านก็แค่นั้น - อาร์เรย์ของอักขระ:

• หากจัดสรรบนสแต็ก (เช่นในตัวอย่างของคุณ) มันจะครอบครองเช่นเสมอ 256 ไบต์ไม่ว่าข้อความจะมีความยาวเท่าใดก็ตาม
• หากจัดสรรบนฮีป (โดยใช้ malloc () หรือถ่านใหม่ []) คุณจะต้องรับผิดชอบในการปล่อยหน่วยความจำในภายหลังและคุณจะมีค่าใช้จ่ายในการจัดสรรฮีปเสมอ
• หากคุณคัดลอกข้อความที่มีมากกว่า 256 ตัวอักษรลงในอาร์เรย์อาจทำให้เกิดข้อผิดพลาดสร้างข้อความยืนยันที่น่าเกลียดหรือทำให้เกิดพฤติกรรมที่ไม่สามารถอธิบายได้ (ผิดพลาด) ที่อื่นในโปรแกรมของคุณ
• ในการกำหนดความยาวของข้อความอาร์เรย์จะต้องถูกสแกนทีละอักขระสำหรับอักขระ \ 0

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

คุณสามารถเข้าถึงอาร์เรย์ของสตริงได้ดังนี้:

std::string myString = "Hello World";
const char *myStringChars = myString.c_str();

สตริง C ++ สามารถมีอักขระ \ 0 ฝังอยู่รู้ความยาวโดยไม่ต้องนับเร็วกว่าอาร์เรย์ถ่านที่จัดสรรแบบฮีปสำหรับข้อความสั้น ๆ และปกป้องคุณจากการโอเวอร์รันบัฟเฟอร์ นอกจากนี้ยังอ่านง่ายขึ้นและใช้งานง่ายขึ้น

อย่างไรก็ตามสตริง C ++ ไม่ (มาก) เหมาะสำหรับการใช้งานข้ามขอบเขต DLL เนื่องจากจะต้องมีผู้ใช้ฟังก์ชัน DLL ดังกล่าวเพื่อให้แน่ใจว่าเขาใช้คอมไพเลอร์และการใช้รันไทม์ C ++ เดียวกันเพื่อมิให้เขาเสี่ยงต่อคลาสสตริงของเขาที่ทำงานแตกต่างกัน

โดยปกติคลาสสตริงจะปล่อยหน่วยความจำฮีปในฮีปการโทรด้วยดังนั้นจึงจะสามารถเพิ่มหน่วยความจำได้อีกครั้งหากคุณใช้รันไทม์เวอร์ชันแชร์ (.dll หรือ. so)

กล่าวโดยย่อ: ใช้สตริง C ++ ในฟังก์ชันและวิธีการภายในทั้งหมดของคุณ หากคุณเคยเขียน. dll หรือ. so ให้ใช้สตริง C ในฟังก์ชันสาธารณะของคุณ (dll / so-exposed)

Arkaitz ถูกต้องซึ่งstringเป็นประเภทที่มีการจัดการ สิ่งนี้มีความหมายสำหรับคุณคือคุณไม่ต้องกังวลว่าสตริงจะยาวแค่ไหนและคุณไม่ต้องกังวลเกี่ยวกับการปลดปล่อยหรือจัดสรรหน่วยความจำของสตริงใหม่

ในทางกลับกันchar[]สัญกรณ์ในกรณีข้างต้นได้ จำกัด บัฟเฟอร์อักขระไว้ที่ 256 อักขระ หากคุณพยายามเขียนอักขระมากกว่า 256 ตัวลงในบัฟเฟอร์นั้นอย่างดีที่สุดคุณจะเขียนทับหน่วยความจำอื่นที่โปรแกรมของคุณ "เป็นเจ้าของ" ที่แย่ที่สุดคือคุณจะพยายามเขียนทับหน่วยความจำที่คุณไม่ได้เป็นเจ้าของและระบบปฏิบัติการของคุณจะฆ่าโปรแกรมของคุณทันที

บรรทัดล่าง? สตริงเป็นมิตรกับโปรแกรมเมอร์มากขึ้นถ่าน [] มีประสิทธิภาพมากกว่าสำหรับคอมพิวเตอร์มาก

ประเภทสตริงเป็นคลาสที่ได้รับการจัดการอย่างสมบูรณ์สำหรับสตริงอักขระในขณะที่ char [] ยังคงเป็นสิ่งที่อยู่ใน C ซึ่งเป็นอาร์เรย์ไบต์ที่แสดงสตริงอักขระสำหรับคุณ

ในแง่ของ API และไลบรารีมาตรฐานทุกอย่างถูกนำไปใช้ในรูปแบบของสตริงไม่ใช่ถ่าน [] แต่ยังมีฟังก์ชันมากมายจาก libc ที่รับถ่าน [] ดังนั้นคุณอาจต้องใช้มันสำหรับสิ่งเหล่านั้นนอกเหนือจากที่ฉันต้องการ ใช้ std :: string เสมอ

ในแง่ของประสิทธิภาพแน่นอนว่าบัฟเฟอร์ดิบของหน่วยความจำที่ไม่มีการจัดการมักจะเร็วกว่าสำหรับสิ่งต่างๆมากมาย แต่ให้คำนึงถึงการเปรียบเทียบสตริงเช่น std :: string มีขนาดที่จะตรวจสอบก่อนเสมอในขณะที่ใช้ char [] คุณ ต้องเปรียบเทียบตัวละครทีละตัวละคร

โดยส่วนตัวแล้วฉันไม่เห็นเหตุผลใด ๆ ว่าทำไมเราถึงต้องการใช้ถ่าน * หรือถ่าน [] ยกเว้นเพื่อความเข้ากันได้กับรหัสเก่า std :: string ไม่ช้าไปกว่าการใช้ c-string ยกเว้นว่าจะจัดการการจัดสรรซ้ำให้คุณ คุณสามารถกำหนดขนาดได้เมื่อคุณสร้างและหลีกเลี่ยงการจัดสรรใหม่หากคุณต้องการ เป็นตัวดำเนินการจัดทำดัชนี ([]) ให้การเข้าถึงเวลาคงที่ (และในทุกความหมายของคำนั้นเหมือนกับการใช้ตัวทำดัชนี c-string) การใช้วิธีการที่ช่วยให้คุณได้รับการตรวจสอบความปลอดภัยเช่นกันสิ่งที่คุณไม่ได้รับจากสตริง c เว้นแต่คุณจะเขียนมัน คอมไพเลอร์ของคุณส่วนใหญ่มักจะเพิ่มประสิทธิภาพการใช้ดัชนีในโหมดรีลีส มันง่ายที่จะยุ่งกับ c-strings; สิ่งต่างๆเช่น delete vs delete [] ความปลอดภัยของข้อยกเว้นแม้กระทั่งวิธีการจัดสรร c-string ใหม่

และเมื่อคุณต้องจัดการกับแนวคิดขั้นสูงเช่นการมีสตริง COW และไม่ใช่ COW สำหรับ MT เป็นต้นคุณจะต้องใช้ std :: string

หากคุณกังวลเกี่ยวกับสำเนาตราบใดที่คุณใช้การอ้างอิงและการอ้างอิง const ไม่ว่าคุณจะทำได้คุณจะไม่มีค่าใช้จ่ายใด ๆ เนื่องจากสำเนาและเป็นสิ่งเดียวกับที่คุณทำกับ c-string

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

คิดว่า (char *) เป็น string.begin () ความแตกต่างที่สำคัญคือ (char *) เป็นตัววนซ้ำและ std :: string เป็นคอนเทนเนอร์ หากคุณยึดติดกับสตริงพื้นฐาน a (char *) จะให้สิ่งที่ std :: string :: iterator ทำ คุณสามารถใช้ (ถ่าน *) เมื่อคุณต้องการประโยชน์ของตัววนซ้ำและความเข้ากันได้กับ C แต่นั่นเป็นข้อยกเว้นไม่ใช่กฎ เช่นเคยโปรดระวังตัวทำซ้ำที่ไม่ถูกต้อง เมื่อมีคนพูดว่า (ถ่าน *) ไม่ปลอดภัยนี่คือสิ่งที่พวกเขาหมายถึง ปลอดภัยพอ ๆ กับตัวทำซ้ำ C ++ อื่น ๆ

ความแตกต่างอย่างหนึ่งคือการยกเลิก Null (\ 0)

ในภาษา C และ C ++ ถ่าน * หรือถ่าน [] จะนำตัวชี้ไปยังถ่านตัวเดียวเป็นพารามิเตอร์และจะติดตามไปตามหน่วยความจำจนกว่าจะถึงค่าหน่วยความจำ 0 (มักเรียกว่าเทอร์มิเนเตอร์ null)

สตริง C ++ สามารถมีอักขระ \ 0 ฝังอยู่รู้ความยาวโดยไม่ต้องนับ

#include<stdio.h>
#include<string.h>
#include<iostream>

using namespace std;

void NullTerminatedString(string str){
   int NUll_term = 3;
   str[NUll_term] = '\0';       // specific character is kept as NULL in string
   cout << str << endl <<endl <<endl;
}

void NullTerminatedChar(char *str){
   int NUll_term = 3;
   str[NUll_term] = 0;     // from specific, all the character are removed 
   cout << str << endl;
}

int main(){
  string str = "Feels Happy";
  printf("string = %s\n", str.c_str());
  printf("strlen = %d\n", strlen(str.c_str()));  
  printf("size = %d\n", str.size());  
  printf("sizeof = %d\n", sizeof(str)); // sizeof std::string class  and compiler dependent
  NullTerminatedString(str);


  char str1[12] = "Feels Happy";
  printf("char[] = %s\n", str1);
  printf("strlen = %d\n", strlen(str1));
  printf("sizeof = %d\n", sizeof(str1));    // sizeof char array
  NullTerminatedChar(str1);
  return 0;
}

เอาท์พุท:

strlen = 11
size = 11
sizeof = 32  
Fee s Happy


strlen = 11
sizeof = 12
Fee