วิธีการแปลงชนิดข้อมูลใน C++

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

วิธีการแปลงชนิดข้อมูลใน C++

ใน C++ มีสองวิธีในการเปลี่ยนประเภทข้อมูล:

การแปลงประเภทโดยนัย
การแปลงประเภทที่ชัดเจน

การแปลงประเภทโดยนัย

ตามกฎที่กำหนดไว้ล่วงหน้าโดยคอมไพลเลอร์โค้ด C++ การแปลงประเภทโดยนัยคือการแปลงประเภทที่ดำเนินการโดยคอมไพเลอร์โดยอัตโนมัติ โดยไม่ต้องใช้ทริกเกอร์ภายนอกจากผู้ใช้ การแปลงประเภทนี้มักจะเกิดขึ้นในโปรแกรมเมื่อมีประเภทข้อมูลมากกว่าหนึ่งประเภท และประเภทข้อมูลของนิพจน์ไม่ตรงกับประเภทข้อมูลของตัวแปรที่เกี่ยวข้องกับนิพจน์นี้

เพื่อหลีกเลี่ยงการสูญเสียข้อมูลระหว่างการแปลง คอมไพลเลอร์โดยค่าเริ่มต้นจะเปลี่ยนประเภทข้อมูลที่แม่นยำต่ำเป็นประเภทข้อมูลที่มีความแม่นยำสูงกว่า ตัวอย่างเช่น มันจะแปลงจำนวนเต็มเป็นจำนวนทศนิยม แทนที่จะเปลี่ยนจำนวนทศนิยมให้เป็นจำนวนเต็มเพื่อป้องกันข้อมูลสูญหาย นี่เรียกว่าการส่งเสริมการขาย ต่อไปนี้เป็นแผนภาพลำดับความสำคัญสำหรับชนิดข้อมูลต่างๆ

คำสั่งสำหรับการแปลงประเภท

ลำดับที่ถูกต้องสำหรับการแปลงประเภทได้รับดังนี้:

บูล -- > ถ่าน -- > อินท์สั้นๆ -- > อินท์ -- > int ที่ไม่ได้ลงนาม -- > ยาว -- > ยาวไม่ได้ลงนาม -- > ยาว ยาว -- > ลอย -- > สองเท่า -- > ยาวสองเท่า

ตัวแปรประเภทความแม่นยำต่ำจะถูกแปลงเป็นประเภทข้อมูลความแม่นยำสูงเพื่อป้องกันข้อมูลสูญหาย

ตัวอย่างที่ 1

ในตัวอย่างนี้ จะมีการบวกกับตัวแปรของประเภทข้อมูลที่แตกต่างกันโดยใช้การแปลงประเภทโดยนัย

#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;

ภายใน หลัก ( ) {
ภายใน ตัวเลข = 100 ;
ถ่าน อักขระ = 'ค' ;
ศาล << '100 + 'ค' = ' << ตัวเลข + อักขระ << สิ้นสุด ;

ลอย วาล = ตัวเลข + 'ค' ;
ศาล << 'ค่าลอยตัว (100 + 'c') = ' << วาล << สิ้นสุด ;

ภายใน เคยเป็น = 7890 ;
ยาว ไม่ได้ = เคยเป็น ;
ศาล << 'var_int = ' << ไม่ได้ ;
กลับ 0 ;
}

นี่คือจำนวนเต็มและอักขระจากตาราง ASCII และตัวเลขทศนิยมและอักขระ 'c' จะถูกเพิ่มเข้าไป จำนวนเต็มจะถูกเก็บไว้ในส่วนที่สามเป็นชนิดข้อมูลแบบยาว และชนิดข้อมูลจะถูกเปลี่ยนโดยคอมไพเลอร์เองตามกฎที่กำหนดไว้ล่วงหน้า

ผลรวมของ 100 และ 'C' ส่งคืน 167 เมื่อ 'C' เท่ากับ 67 ในตัวเลข และ 100+'c' ส่งคืน 199 เป็นตัวพิมพ์เล็ก 'c' เท่ากับ 99 ตัวแปร int จะถูกจัดเก็บไว้ในชนิดข้อมูลขนาดยาว

ตัวอย่างที่ 2

ในตัวอย่างนี้ อักขระ D จะถูกแปลงเป็นทศนิยมเพื่อดำเนินการหาร

#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;

ภายใน หลัก ( ) {
ถ่าน x = 'ดี' ;

ลอย float_var ;

float_var = ลอย ( x ) / 'ค' ;
// แปลง int เป็น float อย่างชัดเจน

ศาล << 'ค่าของ float_var คือ: ' << float_var << สิ้นสุด ;

กลับ 0 ;
}

ค่าอินพุตจะอยู่ในรูปแบบของอักขระ D ซึ่งจัดเก็บไว้ในประเภทข้อมูล float และหารเพิ่มเติมด้วยอักขระ C อักขระเหล่านี้จะเปลี่ยนเป็นค่าตัวเลขและดำเนินการหารกับอักขระเหล่านั้น โดยส่งกลับค่าในรูปแบบทศนิยม

การแปลงประเภทที่ชัดเจน

ผู้ใช้จะต้องแก้ไขประเภทข้อมูลด้วยตนเองด้วยการแปลงประเภทที่ชัดเจนของ C ++ ซึ่งมักเรียกว่าการคัดเลือกประเภท การหล่อประเภทนี้ทำเพื่อหลีกเลี่ยงการแปลงประเภทโดยนัย มีสองวิธีในการดำเนินการ Explicit Type Casting ใน C ++:

การแปลงโดยใช้ตัวดำเนินการที่ได้รับมอบหมาย
การแปลงโดยใช้ Cast Operator

พิมพ์ Conversion โดยใช้ Assignment Operator ใน C ++

การแปลงประเภทโดยใช้ Assignment Operator ทำได้สำเร็จ กล่าวคือ ประเภทข้อมูลหนึ่งจะถูกแปลงเป็นอีกประเภทหนึ่งด้วยตนเอง ซึ่งทำได้โดยใช้ตัวดำเนินการกำหนด “=” ซึ่งจะกำหนดค่าของตัวถูกดำเนินการทางขวาให้กับตัวแปรทางด้านซ้าย

ตัวอย่าง
โปรแกรมนี้คำนวณพื้นที่ของวงกลมโดยใช้การหล่อแบบ

#รวม
#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( )
{
ภายใน รัศมี ;
ศาล <> รัศมี ;
ลอย พื้นที่ = M_PI * รัศมี * รัศมี ;
ศาล << “พื้นที่วงกลมมีรัศมี” << รัศมี << ' = ' << พื้นที่ ;
}

ตัวดำเนินการกำหนดใช้เพื่อกำหนดค่าทศนิยมให้กับพื้นที่ ซึ่งประกอบด้วยค่ารัศมีในรูปแบบข้อมูลจำนวนเต็ม

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

พิมพ์การแปลงโดยใช้ตัวดำเนินการ Cast ใน C ++

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

มีผู้ดำเนินการนักแสดงที่แตกต่างกันสี่คน:

static_cast
const_cast
dynamic_cast
ตีความใหม่_cast

1: static_cast

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

ไวยากรณ์

static_cast ( การแสดงออก )

ตัวอย่าง
โปรแกรมนี้ถูกสร้างขึ้นเพื่อแปลงตัวแปรคู่ให้เป็นชนิดข้อมูล int โดยใช้ static_cast มันจะตัดส่วนทศนิยมในเอาต์พุตออก

#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( )
{
//ประกาศตัวแปร
สองเท่า พี ;
พี = 2,905 * 1,235 * 24,675 ;
ลอย ผลลัพธ์ ;

ศาล << ' ก่อนที่จะใช้การร่ายแบบคงที่:' << สิ้นสุด ;
ศาล << ' ค่าของ p = ' << พี << สิ้นสุด ;

// ใช้ static_cast เพื่อแปลงชนิดข้อมูล
ผลลัพธ์ = static_cast ( พี ) ;
ศาล << ' หลังจากใช้การร่ายแบบคงที่: ' << สิ้นสุด ;
ศาล << ' ค่าของผลลัพธ์ = ' << ผลลัพธ์ << สิ้นสุด ;

กลับ 0 ;
}

เริ่มแรก ตัวแปรคู่ p จะถูกโหลดด้วยค่าที่คูณกันและเก็บไว้ในผลลัพธ์ ผลลัพธ์ประกอบด้วยผลลัพธ์ก่อนและหลังตัวดำเนินการ static_cast:

ก่อนที่จะใช้ตัวดำเนินการ static_cast ผลลัพธ์จะแสดงเป็นจุดทศนิยม ในขณะที่หลังจากใช้ตัวดำเนินการนี้ ผลลัพธ์จะแสดงเป็นชนิดข้อมูลจำนวนเต็ม

2: const_cast

ตัวดำเนินการ const_cast ใช้ในการแปลงค่าคงที่ของวัตถุให้เป็นประเภทที่ไม่คงที่ มันถูกใช้เมื่อมีการประกาศวัตถุคงที่ และเราจำเป็นต้องเปลี่ยนค่าของมันเป็นครั้งคราว

ไวยากรณ์

const_cast ( การแสดงออก )

ตัวอย่าง
ในตัวอย่างนี้ ตัวดำเนินการ const_cast ใช้เพื่อลบตัวระบุคงที่ชั่วคราวและอนุญาตให้ทำการเปลี่ยนแปลงในตัวแปรตามความต้องการ:

#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( ) {
ค่าคงที่ ภายใน x = 70 ;
ค่าคงที่ ภายใน * และ = & x ;
ศาล << “คุณค่าเก่าคือ” << * และ << ' \n ' ;
ภายใน * กับ = const_cast ( และ ) ;
* กับ = 90 ;
ศาล << 'ค่าใหม่คือ' << * และ ;
กลับ 0 ;
}

ตัวระบุคงที่ถูกกำหนดให้กับตัวแปร int x ซึ่งหมายความว่าตัวแปรนี้ไม่สามารถแก้ไขได้โดยตรง หลังจากนั้น int *y ซึ่งเป็นพอยน์เตอร์จะถูกใช้เพื่อเข้าถึง x แต่ก็ยังไม่สามารถเปลี่ยนแปลงได้ และค่าเดิมจะแสดงโดยใช้ cout การใช้ตัวดำเนินการ const_cast ตัวชี้ z จะถูกสร้างขึ้นซึ่งไม่คงที่ ใช้เพื่อเข้าถึงค่า x ทำให้สามารถแก้ไขได้ มันเปลี่ยนค่าที่กำหนดให้กับ z ด้วย 90 ซึ่งจะเปลี่ยนค่าทางอ้อมใน x

ในตอนแรก ค่าของตัวแปรคงที่ x คือ 70 ซึ่งได้รับการแก้ไขโดยใช้ตัวดำเนินการ const_cast ทำให้เป็น 90

3: ไดนามิก_แคสต์

ด้วยลำดับชั้นของการสืบทอด ซึ่งเรียกอีกอย่างว่าการดาวน์คาสต์แบบปลอดภัย การหล่อลงเป็นกระบวนการของการแปลงการอ้างอิงหรือตัวชี้เป็นคลาสที่ได้รับจากการอ้างอิงคลาสพื้นฐานหรือตัวชี้

ไวยากรณ์

dynamic_cast ( การแสดงออก )

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

#รวม
#รวม <ข้อยกเว้น>
โดยใช้ เนมสเปซ มาตรฐาน ;
ระดับ ทีเบส
{
สาธารณะ : :
ลอย ฐาน_g = 9.81 ;

เสมือน เป็นโมฆะ หุ่นเชิด ( )
{

} ;
} ;

ระดับ TDerived : : สาธารณะ ทีเบส
{
สาธารณะ : :
ภายใน local_g = 9.78 ;
} ;

ภายใน หลัก ( )
{

ทีเบส * ฐาน = ใหม่ TDerived ;
TDerived * ได้มา ;

ได้มา = dynamic_cast ( ฐาน ) ;

ศาล < ฐาน_g << สิ้นสุด ;
ศาล < local_g << สิ้นสุด ;

รับชาร์ ( ) ;
กลับ 0 ;
}

สองคลาสถูกกำหนดให้เป็นคลาสพื้นฐานและคลาสที่ได้รับ ฐานตัวชี้ประเภท TBase* ถูกสร้างขึ้นและกำหนดให้กับออบเจ็กต์ประเภท TDerived ที่จัดสรรแบบไดนามิก วัตถุคลาสที่ได้รับสามารถกำหนดให้กับตัวชี้คลาสฐานในกรณีของความหลากหลายนี้ dynamic_cast ตรวจสอบว่าตัวชี้เข้าถึงวัตถุที่ถูกต้องของ TDerived หรือไม่ หากการร่ายได้รับผลลัพธ์ที่สำเร็จ คลาสที่ได้รับจะได้รับผลลัพธ์ที่ถูกต้อง มิฉะนั้นจะส่งกลับค่าว่าง

4: ตีความ_cast ใหม่

reตีความ_cast แปลงตัวชี้ของชนิดข้อมูลหนึ่งเป็นตัวชี้ของชนิดข้อมูลที่แตกต่างกัน ไม่ได้ตรวจสอบว่าชนิดข้อมูลของพอยน์เตอร์เหมือนกันหรือไม่ ผู้ดำเนินการหล่อนี้จำเป็นต้องใช้และจัดการอย่างระมัดระวัง

ตัวอย่าง
ในภาพประกอบนี้ ตัวชี้ของประเภทข้อมูลหนึ่งจะถูกตีความใหม่เป็นตัวชี้ของข้อมูลประเภทอื่นโดยใช้ reตีความ_cast:

#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;

ภายใน หลัก ( )
{
ภายใน * ถาม = ใหม่ ภายใน ( 70 ) ;
ถ่าน * ช = ตีความใหม่_cast ( ถาม ) ;
ศาล << * ถาม << สิ้นสุด ;
ศาล << * ช << สิ้นสุด ;
ศาล << ถาม << สิ้นสุด ;
ศาล << ช << สิ้นสุด ;
กลับ 0 ;
}

เริ่มแรกกำหนดจำนวนเต็มด้วยค่า 70 ตัวชี้ q ชี้ไปที่จำนวนเต็มที่จัดสรรแบบไดนามิกนี้ reตีความ_cast ใช้เพื่อตีความตัวชี้ q ใหม่เป็นตัวชี้อักขระ ch ซึ่งหมายความว่าหน่วยความจำที่เดิมกำหนดให้กับ q จะได้รับการปฏิบัติราวกับว่าเป็นอักขระ การใช้คำสั่ง cout จะพิมพ์ค่าที่กำหนดให้กับ q และ ch เนื่องจาก ch ถือเป็นตัวชี้อักขระ จึงจะส่งกลับค่าอักขระ

มันพิมพ์ค่าที่ชี้ไปที่ ch โดยใช้ *ch อย่างไรก็ตาม เนื่องจาก ch ถือเป็นตัวชี้อักขระ บรรทัดนี้จะตีความหน่วยความจำเป็นอักขระ มันพิมพ์ที่อยู่หน่วยความจำที่เก็บไว้ในตัวชี้ ch โดยใช้ ch นี่คือที่อยู่หน่วยความจำเดียวกันกับ q เนื่องจากเป็นเพียงการตีความใหม่ของหน่วยความจำเดียวกัน

ในตอนแรก จำนวนเต็มเก็บ 70 ต่อมา ค่านี้จะถูกจัดการระหว่างตัวชี้ q และตัวชี้ ch เอาต์พุต 2 และ 4 เหมือนกันเนื่องจากค่าที่สองถูกตีความใหม่โดยใช้ reตีความ_cast

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

บทสรุป

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

วิธีการแปลงชนิดข้อมูลใน C++