อะไรคือความแตกต่างระหว่าง #include <filename> และ #include“ filename”

ในภาษาการเขียนโปรแกรม C และ C ++ ความแตกต่างระหว่างการใช้วงเล็บมุมและการใช้อัญประกาศในincludeคำสั่งมีดังนี้

1. #include <filename>
2. #include "filename"

ในทางปฏิบัติความแตกต่างอยู่ในตำแหน่งที่ตัวประมวลผลล่วงหน้าค้นหาไฟล์ที่รวมอยู่

สำหรับ#include <filename>การค้นหาตัวประมวลผลล่วงหน้าในลักษณะขึ้นอยู่กับการใช้งานตามปกติในไดเรกทอรีการค้นหาที่กำหนดไว้ล่วงหน้าโดยคอมไพเลอร์ / IDE โดยปกติจะใช้วิธีนี้เพื่อรวมไฟล์ส่วนหัวของไลบรารีมาตรฐาน

สำหรับ#include "filename"ตัวประมวลผลก่อนค้นหาในไดเรกทอรีเดียวกันเป็นไฟล์ที่มีคำสั่งจากนั้นตามเส้นทางการค้นหาที่ใช้สำหรับ#include <filename>ฟอร์ม โดยปกติจะใช้วิธีนี้เพื่อรวมไฟล์ส่วนหัวที่โปรแกรมเมอร์กำหนด

คำอธิบายที่สมบูรณ์มากขึ้นมีให้บริการในจีซีเอกสารเกี่ยวกับเส้นทางการค้นหา

วิธีเดียวที่จะรู้คือการอ่านเอกสารการใช้งานของคุณ

ในมาตรฐาน Cส่วน 6.10.2 ย่อหน้า 2 ถึง 4 สถานะ:

• คำสั่ง preprocessing ของแบบฟอร์ม

  #include <h-char-sequence> new-line

  ค้นหาสถานที่ลำดับของการดำเนินงานที่กำหนดไว้สำหรับเป็นหัวระบุไม่ซ้ำกันโดยลำดับที่ระบุระหว่าง<และ>ตัวคั่นและทำให้เกิดการเปลี่ยนคำสั่งว่าโดยเนื้อหาทั้งหมดของส่วนหัว วิธีระบุสถานที่หรือส่วนหัวที่ระบุนั้นมีการนำมาใช้

• คำสั่ง preprocessing ของแบบฟอร์ม

  #include "q-char-sequence" new-line

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

  #include <h-char-sequence> new-line

  ด้วยลำดับที่มีอยู่เหมือนกัน (รวมถึง>อักขระถ้ามี) จากคำสั่งดั้งเดิม

• คำสั่ง preprocessing ของแบบฟอร์ม

  #include pp-tokens new-line

  (ที่ไม่ตรงกับหนึ่งในสองรูปแบบก่อนหน้านี้) ได้รับอนุญาต โทเค็นการประมวลผลล่วงหน้าหลังจากincludeอยู่ในคำสั่งจะถูกประมวลผลเช่นเดียวกับในข้อความปกติ (แต่ละตัวระบุที่กำหนดในปัจจุบันเป็นชื่อแมโครจะถูกแทนที่ด้วยรายการการแทนที่โทเค็นการประมวลผลล่วงหน้า) คำสั่งที่เกิดขึ้นหลังจากการแทนที่ทั้งหมดจะต้องตรงกับหนึ่งในสองรูปแบบก่อนหน้านี้ วิธีที่ลำดับของโทเค็นการประมวลผลล่วงหน้าระหว่าง a <และ>โทเค็นการประมวลผลล่วงหน้าหรือคู่ของ"อักขระจะรวมกันเป็นชื่อส่วนหัวเดียวโทเค็น preprocessing โทเค็นการดำเนินงานที่กำหนดไว้

คำนิยาม:

• h-char: สมาชิกของชุดอักขระต้นฉบับยกเว้นอักขระบรรทัดใหม่และ >

• q-char: สมาชิกของชุดอักขระต้นฉบับยกเว้นอักขระบรรทัดใหม่และ "

ลำดับของอักขระระหว่าง <และ> อ้างอิงถึงส่วนหัวซึ่งไม่จำเป็นต้องเป็นไฟล์ การใช้งานนั้นฟรีมากที่จะใช้ลำดับอักขระตามที่ต้องการ (ส่วนใหญ่อย่างไรก็ตามเพียงถือเป็นชื่อไฟล์และทำการค้นหาในเส้นทางรวมเป็นรัฐโพสต์อื่น ๆ )

หาก#include "file"มีการใช้แบบฟอร์มการใช้งานครั้งแรกจะมองหาไฟล์ที่มีชื่อที่กำหนดหากได้รับการสนับสนุน หากไม่ได้รับการสนับสนุน (หรือสนับสนุน) หรือการค้นหาล้มเหลวการใช้งานจะมีลักษณะเหมือนกับว่าใช้#include <file>รูปแบบอื่น ( )

นอกจากนี้ยังมีรูปแบบที่สามและใช้เมื่อ#includeคำสั่งไม่ตรงกับรูปแบบใดรูปแบบหนึ่งด้านบน ในแบบฟอร์มนี้การประมวลผลล่วงหน้าขั้นพื้นฐานบางอย่าง (เช่นการขยายมาโคร) จะทำใน "ตัวถูกดำเนินการ" ของ#includeคำสั่งและคาดว่าผลลัพธ์จะตรงกับหนึ่งในสองรูปแบบอื่น ๆ

บางคำตอบที่ดีที่นี่อ้างอิงถึงมาตรฐาน C แต่ลืมมาตรฐาน POSIX โดยเฉพาะพฤติกรรมที่เฉพาะเจาะจงของคำสั่งc99 (เช่น C คอมไพเลอร์)

ตามคุณสมบัติที่เปิดฐานกลุ่มฉบับที่ 7 ,

ไดเรกทอรีฉัน

เปลี่ยนอัลกอริทึมสำหรับการค้นหาสำหรับส่วนหัวที่มีชื่ออยู่ pathnames ไม่แน่นอนที่จะมองในไดเรกทอรีชื่อโดยไดเรกทอรีชื่อพา ธ ก่อนที่จะมองในสถานที่ตามปกติ ดังนั้นส่วนหัวที่มีชื่ออยู่ในเครื่องหมายคำพูดคู่ ("") จะถูกค้นหาครั้งแรกในไดเรกทอรีของไฟล์ที่มีบรรทัด#includeจากนั้นในไดเรกทอรีที่มีชื่อในตัวเลือก-Iและสุดท้ายในสถานที่ปกติ สำหรับส่วนหัวที่มีชื่ออยู่ในวงเล็บมุม ("<>") ส่วนหัวจะถูกค้นหาเฉพาะในไดเรกทอรีที่มีชื่อในตัวเลือก-Iแล้วในสถานที่ปกติ ไดเรกทอรีที่มีชื่อในตัวเลือก-Iจะถูกค้นหาตามลำดับที่ระบุc99อุทธรณ์คำสั่ง

ดังนั้นในสภาพแวดล้อมที่สอดคล้องกับ POSIX กับคอมไพเลอร์ที่เข้ากันได้กับ POSIX POSIX #include "file.h"มีแนวโน้มที่จะค้นหา./file.hก่อนโดยที่.เป็นไดเรกทอรีที่เป็นไฟล์ที่มี#includeคำสั่งในขณะที่#include <file.h>มีแนวโน้มที่จะค้นหา/usr/include/file.hครั้งแรกที่/usr/includeระบบของคุณกำหนดไว้สถานที่ปกติสำหรับส่วนหัว (ดูเหมือนว่าไม่ได้กำหนดโดย POSIX)

เอกสาร GCC กล่าวว่าสิ่งต่อไปนี้เกี่ยวกับความแตกต่างระหว่างทั้งสอง:

‘#include’ทั้งผู้ใช้และระบบหัวรวมไฟล์โดยใช้คำสั่ง preprocessing มันมีสองสายพันธุ์:

#include <file>

ตัวแปรนี้ใช้สำหรับไฟล์ส่วนหัวของระบบ มันค้นหาไฟล์ชื่อไฟล์ในรายการมาตรฐานของไดเรกทอรีระบบ คุณสามารถย่อหน้าไดเรกทอรีในรายการนี้กับ-Iตัวเลือก (ดูภาวนา )

#include "file"

ตัวแปรนี้ใช้สำหรับไฟล์ส่วนหัวของโปรแกรมของคุณเอง <file>จะค้นหาไฟล์ไฟล์ชื่อแรกในไดเรกทอรีที่มีไฟล์ปัจจุบันแล้วในไดเรกทอรีที่อ้างแล้วไดเรกทอรีเดียวกับที่ใช้สำหรับ คุณสามารถเพิ่มไดเรกทอรีลงในรายการไดเรกทอรีเสนอราคาด้วย-iquoteตัวเลือก อาร์กิวเมนต์ของ‘#include’ว่าไม่ว่าจะคั่นด้วยเครื่องหมายอัญประกาศหรือวงเล็บมุมทำตัวเหมือนค่าคงที่สตริงในความคิดเห็นที่ไม่เป็นที่รู้จักและชื่อแมโครจะไม่ขยาย ดังนั้นระบุรวมของไฟล์ระบบหัวชื่อ#include <x/*y>x/*y

อย่างไรก็ตามหากแบ็กสแลชเกิดขึ้นภายในไฟล์ถือว่าเป็นอักขระข้อความธรรมดาไม่ใช่อักขระยกเว้น ไม่มีการประมวลผลลำดับอักขระที่เหมาะสมกับค่าคงที่สตริงใน C ที่ถูกประมวลผล ดังนั้น#include "x\n\\y"ระบุชื่อไฟล์ที่มีแบ็กสแลชสามรายการ (ระบบบางระบบตีความ '\' เป็นตัวคั่นพา ธ ทั้งหมดเหล่านี้ตีความ‘/’ในลักษณะเดียวกันมันเป็นแบบพกพามากที่สุดที่จะใช้เท่านั้น‘/’)

มันเป็นข้อผิดพลาดหากมีสิ่งใด (นอกเหนือจากความคิดเห็น) ในบรรทัดหลังชื่อไฟล์

มันทำ:

"mypath/myfile" is short for ./mypath/myfile

ด้วย.การเป็นไดเรกทอรีของไฟล์ที่#includeมีอยู่ในและ / หรือไดเรกทอรีการทำงานปัจจุบันของคอมไพเลอร์และ / หรือdefault_include_paths

และ

<mypath/myfile> is short for <defaultincludepaths>/mypath/myfile

ถ้า./อยู่ใน<default_include_paths>นั้นมันไม่ได้สร้างความแตกต่าง

หากmypath/myfileอยู่ในไดเรกทอรีอื่นรวมถึงพฤติกรรมที่ไม่ได้กำหนด

การ<file>รวมบอกให้ตัวประมวลผลล่วงหน้าค้นหาใน-Iไดเร็กทอรีและในไดเร็กทอรีที่กำหนดไว้ล่วงหน้าก่อนจากนั้นในไดเร็กทอรีของไฟล์. c การ"file"รวมจะบอกให้ตัวประมวลผลล่วงหน้าค้นหาไดเร็กทอรีของไฟล์ต้นฉบับก่อนจากนั้นจึงย้อนกลับ-Iและกำหนดไว้ล่วงหน้า ทุกสถานที่มีการค้นหาต่อไปเพียงเพื่อการค้นหาที่แตกต่างกัน

มาตรฐาน 2011 ส่วนใหญ่กล่าวถึงการรวมไฟล์ใน "16.2 แหล่งรวมไฟล์"

2 preprocessing สั่งของแบบฟอร์ม

# include <h-char-sequence> new-line

ค้นหาลำดับของตำแหน่งที่กำหนดการนำไปใช้งานเพื่อค้นหาส่วนหัวที่ระบุโดยไม่ซ้ำกันตามลำดับที่ระบุระหว่างตัวคั่น <และ> และทำให้การเปลี่ยนคำสั่งนั้นโดยเนื้อหาทั้งหมดของส่วนหัว วิธีระบุสถานที่หรือส่วนหัวที่ระบุนั้นมีการนำมาใช้

3 คำสั่ง preprocessing ของแบบฟอร์ม

# include "q-char-sequence" new-line

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

# include <h-char-sequence> new-line

ด้วยลำดับที่มีเหมือนกัน (รวมถึง> อักขระถ้ามี) จากคำสั่งดั้งเดิม

โปรดสังเกตว่า"xxx"รูปแบบจะลดลงเป็น<xxx>รูปแบบหากไม่พบไฟล์ ส่วนที่เหลือคือการดำเนินการที่กำหนดไว้

#include <file.h>บอกคอมไพเลอร์เพื่อค้นหาส่วนหัวในไดเรกทอรี " file.hinclude " ของมันเช่นสำหรับ MinGW คอมไพเลอร์จะค้นหาใน C: \ MinGW \ include \ หรือติดตั้งที่ใดที่คอมไพเลอร์ของคุณ

#include "file"บอกคอมไพเลอร์ที่จะค้นหาไดเรกทอรีปัจจุบัน (IE ไดเรกทอรีที่อยู่ของแหล่งที่มาของไฟล์) fileสำหรับ

คุณสามารถใช้-Iธง GCC จะบอกว่าเมื่อมันพบข้อ ได้แก่ -Iมีวงเล็บมุมก็ยังควรค้นหาส่วนหัวในไดเรกทอรีหลัง GCC จะปฏิบัติต่อไดเรกทอรีหลังจากธงราวกับว่ามันเป็นincludesไดเรกทอรี

ตัวอย่างเช่นหากคุณมีไฟล์ชื่อmyheader.hในไดเรกทอรีของคุณเองคุณสามารถพูดได้ว่า#include <myheader.h>คุณเรียกว่า GCC พร้อมกับตั้งค่าสถานะ-I .(ระบุว่าควรจะค้นหาไฟล์นั้นรวมอยู่ในไดเรกทอรีปัจจุบัน)

โดยไม่ต้อง-Iธงคุณจะต้องใช้#include "myheader.h"ในการรวมไฟล์หรือย้ายmyheader.hไปยังincludeไดเรกทอรีของคอมไพเลอร์ของคุณ

ตามมาตรฐาน - ใช่พวกเขาแตกต่างกัน:

• คำสั่ง preprocessing ของแบบฟอร์ม

  #include <h-char-sequence> new-line

  ค้นหาลำดับของสถานที่ที่กำหนดให้มีการนำไปใช้งานสำหรับส่วนหัวที่ระบุโดยไม่ซ้ำกันตามลำดับที่ระบุระหว่าง<และ>ตัวคั่นและทำให้การเปลี่ยนคำสั่งนั้นโดยเนื้อหาทั้งหมดของส่วนหัว วิธีระบุสถานที่หรือส่วนหัวที่ระบุนั้นมีการนำมาใช้

• คำสั่ง preprocessing ของแบบฟอร์ม

  #include "q-char-sequence" new-line

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

  #include <h-char-sequence> new-line

  ด้วยลำดับที่มีอยู่เหมือนกัน (รวมถึง>อักขระถ้ามี) จากคำสั่งดั้งเดิม

• คำสั่ง preprocessing ของแบบฟอร์ม

  #include pp-tokens new-line

  (ที่ไม่ตรงกับหนึ่งในสองรูปแบบก่อนหน้านี้) ได้รับอนุญาต โทเค็นการประมวลผลล่วงหน้าหลังจากincludeอยู่ในคำสั่งจะถูกประมวลผลเช่นเดียวกับในข้อความปกติ (แต่ละตัวระบุที่กำหนดในปัจจุบันเป็นชื่อแมโครจะถูกแทนที่ด้วยรายการการแทนที่โทเค็นการประมวลผลล่วงหน้า) คำสั่งที่เกิดขึ้นหลังจากการแทนที่ทั้งหมดจะต้องตรงกับหนึ่งในสองรูปแบบก่อนหน้านี้ วิธีที่ลำดับของโทเค็นการประมวลผลล่วงหน้าระหว่าง a <และ>โทเค็นการประมวลผลล่วงหน้าหรือคู่ของ"อักขระจะรวมกันเป็นชื่อส่วนหัวเดียวโทเค็น preprocessing โทเค็นการดำเนินงานที่กำหนดไว้

คำนิยาม:

• h-char: สมาชิกของชุดอักขระต้นฉบับยกเว้นอักขระบรรทัดใหม่และ >

• q-char: สมาชิกของชุดอักขระต้นฉบับยกเว้นอักขระบรรทัดใหม่และ "

โปรดทราบว่ามาตรฐานไม่ได้บอกความสัมพันธ์ใด ๆ ระหว่างมารยาทที่กำหนดโดยการนำไปปฏิบัติ รูปแบบแรกจะค้นหาในวิธีที่กำหนดโดยการนำไปใช้งานหนึ่งและอีกวิธีหนึ่งในวิธีกำหนดใช้งาน มาตรฐานยังระบุด้วยว่าจะต้องมีไฟล์รวมอยู่ด้วย (เช่น<stdio.h>)

คุณต้องอ่านคู่มืออย่างเป็นทางการสำหรับคอมไพเลอร์ของคุณ แต่ตามปกติ (ตามธรรมเนียม) #include "..."รูปแบบจะค้นหาไดเรกทอรีของไฟล์ที่#includeพบก่อนจากนั้นไดเรกทอรีที่#include <...>ฟอร์มนั้นค้นหา (พา ธ รวมเช่นส่วนหัวของระบบเช่นส่วนหัวของระบบ )

ขอบคุณสำหรับคำตอบที่ดี Adam Stelmaszczyk และ piCookie และ aib

เช่นเดียวกับโปรแกรมเมอร์หลายคนฉันใช้แบบแผนทางการของการใช้"myApp.hpp"แบบฟอร์มสำหรับไฟล์เฉพาะแอปพลิเคชันและ<libHeader.hpp>แบบฟอร์มสำหรับไฟล์ไลบรารีและระบบคอมไพเลอร์เช่นไฟล์ที่ระบุใน/IและINCLUDEตัวแปรสภาพแวดล้อมสำหรับปีที่คิดว่าเป็นมาตรฐาน

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

#include "../../MyProgDir/SourceDir1/someFile.hpp"

MSVS เวอร์ชันเก่าต้องการแบ็กสแลชคู่ (\\) แต่ตอนนี้ไม่จำเป็น ฉันไม่รู้ว่ามันเปลี่ยนไปเมื่อไหร่ เพียงใช้เครื่องหมายทับซ้ายเพื่อเข้ากันได้กับ 'ระวัง (Windows จะยอมรับ)

หากคุณกำลังจริงๆกังวลเกี่ยวกับเรื่องนี้ใช้"./myHeader.h"สำหรับรวมไฟล์ในไดเรกทอรีเดียวกันกับรหัสที่มา (ปัจจุบันโครงการมีขนาดใหญ่มากของฉันมีบางส่วนที่ซ้ำกันรวมถึงชื่อไฟล์เกลื่อนกลาด - จริงๆปัญหาการจัดการการตั้งค่า)

นี่คือคำอธิบายของ MSDN ที่คัดลอกมาที่นี่เพื่อความสะดวกของคุณ)

แบบฟอร์มที่ยกมา

ตัวประมวลผลล่วงหน้าค้นหาไฟล์ include ตามลำดับนี้:

1. ในไดเรกทอรีเดียวกันกับไฟล์ที่มีคำสั่ง #include
2. ในไดเรกทอรีของไฟล์ที่เปิดอยู่ในปัจจุบันเรียงตามลำดับย้อนกลับที่
   เปิดอยู่ การค้นหาเริ่มต้นในไดเรกทอรีของไฟล์ parent รวมถึง
   ขึ้นด้านบนผ่านไดเร็กทอรีของไฟล์ include grandparent ใด ๆ
3. ตามเส้นทางที่ระบุโดย/Iตัวเลือกคอมไพเลอร์แต่ละตัว
4. ตามเส้นทางที่ระบุโดยINCLUDEตัวแปรสภาพแวดล้อม

รูปแบบวงเล็บมุม

ตัวประมวลผลล่วงหน้าค้นหาไฟล์ include ตามลำดับนี้:

1. ตามเส้นทางที่ระบุโดย/Iตัวเลือกคอมไพเลอร์แต่ละตัว
2. เมื่อรวบรวมเกิดขึ้นในบรรทัดคำสั่งพร้อมเส้นทางที่ระบุโดยINCLUDEตัวแปรสภาพแวดล้อม

อย่างน้อยสำหรับรุ่น GCC <= 3.0 รูปแบบวงเล็บมุมจะไม่สร้างการพึ่งพาระหว่างไฟล์ที่รวมและไฟล์ที่รวม

ดังนั้นหากคุณต้องการสร้างกฎการพึ่งพา (ใช้ตัวเลือก GCC -M สำหรับตัวอย่าง) คุณต้องใช้แบบฟอร์มที่ยกมาสำหรับไฟล์ที่ควรจะรวมอยู่ในโครงสร้างการพึ่งพา

(ดูhttp://gcc.gnu.org/onlinedocs/cpp/Invocation.html )

สำหรับ#include ""คอมไพเลอร์โดยปกติแล้วจะค้นหาโฟลเดอร์ของไฟล์ที่มีไฟล์นั้นซึ่งรวมถึงโฟลเดอร์อื่นแล้ว สำหรับ#include <>คอมไพเลอร์ไม่ได้ค้นหาโฟลเดอร์ของไฟล์ปัจจุบัน

เมื่อคุณใช้ #include <filename> ตัวประมวลผลล่วงหน้าจะค้นหาไฟล์ในไดเรกทอรีของไฟล์ส่วนหัว C \ C ++ (stdio.h \ cstdio, สตริง, เวกเตอร์ ฯลฯ ) แต่เมื่อคุณใช้ #include "filename": ก่อนตัวประมวลผลล่วงหน้าจะค้นหาไฟล์ในไดเรกทอรีปัจจุบันและหากไม่อยู่ที่นี่เขาจะค้นหาในไดเรกทอรีของไฟล์ส่วนหัว C \ C ++

#include ที่มีเครื่องหมายวงเล็บมุมจะค้นหา "รายชื่อสถานที่ที่ขึ้นอยู่กับการนำไปใช้งาน" (ซึ่งเป็นวิธีที่ซับซ้อนมากในการพูดว่า "ส่วนหัวของระบบ") เพื่อรวมไฟล์

#include ที่มีเครื่องหมายคำพูดจะค้นหาไฟล์ (และ "ในลักษณะที่ขึ้นกับการนำไปใช้งาน", bleh) ซึ่งหมายความว่าในภาษาอังกฤษปกติมันจะพยายามใช้พา ธ / ชื่อไฟล์ที่คุณโยนไปและจะไม่เพิ่มเส้นทางของระบบหรือยุ่งเกี่ยวกับมันเป็นอย่างอื่น

นอกจากนี้หาก #include "" ล้มเหลวจะถูกอ่านอีกครั้งเป็น #include <> ตามมาตรฐาน

เอกสาร GCCมีคำอธิบาย (คอมไพเลอร์ที่เฉพาะเจาะจง) ซึ่งแม้ว่าจะเป็นที่เฉพาะเจาะจงกับ GCC และไม่ได้มาตรฐานเป็นที่ง่ายมากที่จะเข้าใจกว่าการพูดคุยทนายความสไตล์ของมาตรฐาน ISO

#include "filename" // User defined header
#include <filename> // Standard library header.

ตัวอย่าง:

ชื่อไฟล์ที่นี่คือSeller.h:

#ifndef SELLER_H     // Header guard
#define SELLER_H     // Header guard

#include <string>
#include <iostream>
#include <iomanip>

class Seller
{
    private:
        char name[31];
        double sales_total;

    public:
        Seller();
        Seller(char[], double);
        char*getName();

#endif

ในการปรับใช้คลาส (ตัวอย่างเช่นSeller.cppและในไฟล์อื่น ๆ ที่จะใช้ไฟล์Seller.h) ส่วนหัวที่กำหนดโดยผู้ใช้ควรรวมไว้ในตอนนี้ดังนี้:

#include "Seller.h"

• #include <> ใช้สำหรับไฟล์ส่วนหัวที่กำหนดไว้ล่วงหน้า

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

#include <iostream>

• #include " " สำหรับไฟล์ส่วนหัวที่โปรแกรมเมอร์กำหนด

หากคุณ (โปรแกรมเมอร์) เขียนไฟล์ส่วนหัวของคุณเองคุณจะต้องเขียนชื่อไฟล์ส่วนหัวด้วยเครื่องหมายคำพูด ดังนั้นสมมติว่าคุณเขียนไฟล์ส่วนหัวชื่อmyfile.hนี่คือตัวอย่างของวิธีที่คุณจะใช้คำสั่ง include เพื่อรวมไฟล์นั้น:

#include "myfile.h"

คำตอบมากมายที่นี่ให้ความสำคัญกับเส้นทางที่คอมไพเลอร์จะค้นหาเพื่อค้นหาไฟล์ ในขณะที่สิ่งนี้เป็นสิ่งที่คอมไพเลอร์ส่วนใหญ่ทำคอมไพเลอร์ที่ได้รับอนุญาตจะได้รับการ preprogrammed กับเอฟเฟกต์ของส่วนหัวมาตรฐานและปฏิบัติต่อพูด#include <list>เป็นสวิตช์

นี่ไม่ใช่สมมุติฐานอย่างหมดจด มีคอมไพเลอร์อย่างน้อยหนึ่งตัวที่ทำงานในลักษณะนั้น แนะนำให้ใช้#include <xxx>กับส่วนหัวมาตรฐานเท่านั้น

#include <abc.h>

ถูกใช้เพื่อรวมไฟล์ไลบรารีมาตรฐาน ดังนั้นคอมไพเลอร์จะตรวจสอบในตำแหน่งที่ส่วนหัวของไลบรารีมาตรฐานตั้งอยู่

#include "xyz.h"

จะบอกคอมไพเลอร์ให้รวมไฟล์ส่วนหัวที่ผู้ใช้กำหนด ดังนั้นคอมไพเลอร์จะตรวจสอบไฟล์ส่วนหัวเหล่านี้ในโฟลเดอร์ปัจจุบันหรือ-Iโฟลเดอร์ที่กำหนดไว้

ใน C ++ ให้รวมไฟล์ด้วยสองวิธี:

อันแรกคือ #include ซึ่งบอกให้ preprocessor ค้นหาไฟล์ในตำแหน่งเริ่มต้นที่กำหนดไว้ล่วงหน้า ตำแหน่งนี้มักเป็นตัวแปรสภาพแวดล้อม INCLUDE ที่แสดงพา ธ เพื่อรวมไฟล์

และประเภทที่สองคือ #include "filename" ซึ่งบอกให้ preprocessor ค้นหาไฟล์ในไดเรกทอรีปัจจุบันก่อนจากนั้นค้นหาในตำแหน่งที่ผู้ใช้ตั้งค่าไว้ล่วงหน้า

แบบฟอร์ม 1 - #include <xxx>

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

แบบฟอร์ม 2 - #include "xxx"

สิ่งนี้ค้นหาการมีอยู่ของไฟล์ส่วนหัวในไดเรกทอรีปัจจุบันจากที่มีการเรียกใช้คำสั่ง

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

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

โดยทั่วไปรูปแบบ "xxx" นั้นไม่ได้มีอะไรนอกจากค้นหาในไดเรกทอรีปัจจุบัน หากไม่พบแบบฟอร์มที่ล้มลง

#include <filename>จะใช้เมื่อไฟล์ระบบจะถูกเรียกว่า นั่นคือส่วนหัวของแฟ้มที่สามารถพบได้ในสถานที่เริ่มต้นของระบบเช่นหรือ/usr/include /usr/local/includeสำหรับไฟล์ของคุณที่จะต้องรวมอยู่ในโปรแกรมอื่นคุณจะต้องใช้#include "filename"ไวยากรณ์

การค้นหา "<filename>" ในตำแหน่งไลบรารีมาตรฐาน C

ในขณะที่ "ชื่อไฟล์" ค้นหาในไดเรกทอรีปัจจุบันเช่นกัน

ตามหลักการแล้วคุณจะใช้ <... > สำหรับไลบรารี C มาตรฐานและ "... " สำหรับไลบรารีที่คุณเขียนและมีอยู่ในไดเรกทอรีปัจจุบัน

กฎทั่วไปง่ายๆคือการใช้วงเล็บมุมเพื่อรวมไฟล์ส่วนหัวที่มาพร้อมกับคอมไพเลอร์ ใช้เครื่องหมายคำพูดคู่เพื่อรวมไฟล์ส่วนหัวอื่น ๆ คอมไพเลอร์ส่วนใหญ่ทำแบบนี้

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

ถูกใช้เมื่อคุณต้องการใช้ไฟล์ส่วนหัวของระบบ C / C ++ หรือไลบรารีคอมไพเลอร์ ไลบรารีเหล่านี้สามารถ stdio.h, string.h, math.h เป็นต้น

จะใช้เมื่อคุณต้องการใช้ไฟล์ส่วนหัวที่กำหนดเองซึ่งอยู่ในโฟลเดอร์โครงการหรือที่อื่น

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับตัวประมวลผลล่วงหน้าและส่วนหัว อ่านC - ตัวประมวลผลล่วงหน้า

#include <filename>

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

#include "filename"

• คอมไพเลอร์บอกให้ค้นหาไฟล์ส่วนหัวที่โปรแกรมทำงานอยู่ ถ้ามันล้มเหลวมันจะทำตัวเหมือน#include <filename>และค้นหาไฟล์ส่วนหัวที่ซึ่งเป็นที่เก็บไฟล์ส่วนหัวของระบบ
• วิธีการนี้มักจะใช้เพื่อระบุไฟล์ส่วนหัวที่ผู้ใช้กำหนด (ไฟล์ส่วนหัวที่สร้างโดยผู้ใช้) ที่นั่นอย่าใช้สิ่งนี้หากคุณต้องการเรียก#include <filename>ไลบรารี่มาตรฐานเพราะใช้เวลาในการรวบรวมมากกว่า

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

cpp -v /dev/null -o /dev/null

Apple LLVM เวอร์ชั่น 10.0.0 (เสียงดัง -1000.10.44.2)
เป้าหมาย: x86_64-apple-darwin18.0.0
รุ่นเธรด: posix ติดตั้ง : ไลบรารี / นักพัฒนา / CommandLineTools / usr / bin
"/ Library / Developer / CommandLineTools / usr / bin / clang" -cc1 -triple x86_64-apple-macosx10.14.0 -Wdeprecated-objc-isa-use -Werror = คัดค้าน-objc-isa-use ปิดการใช้งาน -lvm-verifier -discard-value- ชื่อ -main-file-name null -mrelocation-model pic -pic-level 2 -mthread-model posix -mdisable-fp-elim -fno-เข้มงวด-return -masm-verbose - munwind ตาราง -target-cpu penryn -dwarf-column-info -debugger-tuning = lldb -target-linker-version 409.12 -v -resource-dir /Library/Developer/CommandLineTools/usr/lib/clang/10.0 isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk -I / usr / local / รวม -fdebug-compilation-dir / ผู้ใช้ / hogstrom -ferror-limit 19 -fmessage-length 80 -stack-protector-1 -fencode-Extended-block-signature -fobjc-runtime = macosx-10.140 -fmax-type-align = 16 -fdiagnostics-show-option -fcolor-Diagnostics -traditional-cpp -o - -xc / dev / null
clang -cc1 รุ่น 10.0.0 (clang-1000.10.44.2) เป้าหมายเริ่มต้น x86_64-apple-darwin18.0.0 โดยไม่สนใจไดเรกทอรีที่ไม่มีอยู่ "/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/local/include" ไดเรกทอรี "/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/Library/Frameworks"
#include "... " การค้นหาเริ่มต้นที่นี่:
#include <... > การค้นหาเริ่มต้นที่นี่:
/ usr / local / include
/ ห้องสมุด / Developer / CommandLineTools / usr / lib / เสียงดังกราว / 10.0.0 / include
/ Library / Developer / CommandLineTools / usr / รวม
/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/include
/ Library / Developer / CommandLineTools / SDKs / MacOSX10.14.sdk / ระบบ / ไลบรารี / กรอบงาน (ไดเรกทอรีกรอบ)
สิ้นสุดรายการค้นหา

#include <file> 

รวมไฟล์ที่ไดเรกทอรีรวมเป็นค่าเริ่มต้น

#include "file" 

รวมถึงไฟล์ในไดเรกทอรีปัจจุบันที่มันถูกรวบรวม

มีอยู่สองวิธีในการเขียนคำสั่ง #include นี่คือ:

#include"filename"
#include<filename>

ความหมายของแต่ละรูปแบบคือ

#include"mylib.h"

คำสั่งนี้จะค้นหาไฟล์mylib.hในไดเรกทอรีปัจจุบันเช่นเดียวกับรายการไดเรกทอรีที่ระบุดังกล่าว n เส้นทางการค้นหารวมที่อาจได้รับการตั้งค่า

#include<mylib.h>

คำสั่งนี้จะค้นหาไฟล์mylib.hในรายการไดเรกทอรีที่ระบุเท่านั้น

พา ธ การค้นหา include คืออะไรนอกจากรายการไดเร็กทอรีที่จะค้นหาไฟล์ที่ถูกรวมคอมไพเลอร์ C ที่แตกต่างกันให้คุณตั้งค่าพา ธ การค้นหาในลักษณะที่แตกต่างกัน