เป็นไปได้หรือไม่ที่ #include หายไปเพื่อหยุดโปรแกรมเมื่อรันไทม์?

มีกรณีใดบ้างที่ขาดหายไป#includeจะทำให้ซอฟต์แวร์เสียหายขณะรันไทม์ในขณะที่บิลด์ยังดำเนินต่อไป

ในคำอื่น ๆ มันเป็นไปได้ที่

#include "some/code.h"
complexLogic();
cleverAlgorithms();

และ

complexLogic();
cleverAlgorithms();

ทั้งสองจะสร้างได้สำเร็จ แต่ประพฤติแตกต่างกันอย่างไร

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

การวางนิยามแบบโกลบอลในไฟล์ส่วนหัวนั้นมีสไตล์ไม่ดี แต่ก็เป็นไปได้

ใช่มันเป็นไปได้

ทุกสิ่งที่เกี่ยวข้องกับการ#includeเกิดขึ้นในเวลารวบรวม แต่สิ่งที่เวลารวบรวมสามารถเปลี่ยนพฤติกรรมที่รันไทม์แน่นอน:

some/code.h:

#define FOO
int foo(int a) { return 1; }

แล้วก็

#include <iostream>
int foo(float a) { return 2; }

#include "some/code.h"  // Remove that line

int main() {
  std::cout << foo(1) << std::endl;
  #ifdef FOO
    std::cout << "FOO" std::endl;
  #endif
}

ด้วย#includeความละเอียดเกินพบที่เหมาะสมมากขึ้นfoo(int)และด้วยเหตุนี้พิมพ์แทน1 2นอกจากนี้ตั้งแต่มีการกำหนดก็ยังพิมพ์FOO FOO

นั่นเป็นเพียงสองตัวอย่าง (ไม่เกี่ยวข้อง) ที่เข้ามาในความคิดของฉันทันทีและฉันแน่ใจว่ามีอีกมากมาย

เพียงเพื่อชี้ให้เห็นกรณีเล็ก ๆ น้อย ๆ คำสั่ง precompiler:

// main.cpp
#include <iostream>
#include "trouble.h" // comment this out to change behavior

bool doACheck(); // always returns true

int main()
{
    if (doACheck())
        std::cout << "Normal!" << std::endl;
    else
        std::cout << "BAD!" << std::endl;
}

และจากนั้น

// trouble.h
#define doACheck(...) false

มันเป็นพยาธิวิทยาบางที แต่ฉันเคยมีคดีที่เกี่ยวข้องเกิดขึ้น:

#include <algorithm>
#include <windows.h> // comment this out to change behavior

using namespace std;

double doThings()
{
    return max(f(), g());
}

ดูไม่น่ากลัว std::maxพยายามที่จะเรียก อย่างไรก็ตาม windows.h กำหนดได้สูงสุด

#define max(a, b)  (((a) > (b)) ? (a) : (b))

ถ้านี่คือstd::maxนี่จะเป็นการเรียกใช้ฟังก์ชันปกติที่ประเมิน f () หนึ่งครั้งและ g () หนึ่งครั้ง แต่ด้วย windows.h ในนั้นตอนนี้ประเมิน f () หรือ g () สองครั้ง: หนึ่งครั้งในระหว่างการเปรียบเทียบและอีกครั้งเพื่อรับค่าตอบแทน หาก f () หรือ g () ไม่ใช่ idempotent สิ่งนี้อาจทำให้เกิดปัญหาได้ ตัวอย่างเช่นหากหนึ่งในนั้นเกิดขึ้นเป็นเคาน์เตอร์ซึ่งจะส่งกลับจำนวนที่แตกต่างกันทุกครั้ง ....

เป็นไปได้ที่จะไม่มีความเชี่ยวชาญด้านเทมเพลต

// header1.h:

template<class T>
void algorithm(std::vector<T> &ts) {
    // clever algorithm (sorting, for example)
}

class thingy {
    // stuff
};

// header2.h

template<>
void algorithm(std::vector<thingy> &ts) {
    // different clever algorithm
}

// main.cpp

#include <vector>
#include "header1.h"
//#include "header2.h"

int main() {
    std::vector<thingy> thingies;
    algorithm(thingies);
}

ความเข้ากันไม่ได้ของไบนารีการเข้าถึงสมาชิกหรือแย่กว่านั้นคือเรียกฟังก์ชันของคลาสที่ไม่ถูกต้อง:

#pragma once

//include1.h:
#ifndef classw
#define classw

class class_w
{
    public: int a, b;
};

#endif

ฟังก์ชั่นใช้มันและมันก็โอเค:

//functions.cpp
#include <include1.h>
void smartFunction(class_w& x){x.b = 2;}

นำมาในชั้นเรียนอื่น:

#pragma once

//include2.h:
#ifndef classw
#define classw

class class_w
{
public: int a;
};

#endif

การใช้ฟังก์ชั่นในหลักความหมายที่สองเปลี่ยนนิยามคลาส มันนำไปสู่การเข้ากันไม่ได้ของไบนารีและเพียงเกิดปัญหาเมื่อรันไทม์ และแก้ไขปัญหาโดยลบการรวมแรกใน main.cpp:

//main.cpp

#include <include2.h> //<-- Remove this to fix the crash
#include <include1.h>

void smartFunction(class_w& x);
int main()
{
    class_w w;
    smartFunction(w);
    return 0;
}

ไม่มีตัวแปรสร้างข้อผิดพลาดในการรวบรวมหรือลิงค์เวลา

ในทางกลับกันสถานการณ์เพิ่มการรวมการแก้ไขความผิดพลาด:

//main.cpp
//#include <include1.h>  //<-- Add this include to fix the crash
#include <include2.h>
...

สถานการณ์เหล่านี้ยิ่งยากขึ้นเมื่อแก้ไขข้อบกพร่องในโปรแกรมรุ่นเก่าหรือใช้ไลบรารี่ / dll / วัตถุที่แชร์ภายนอก นั่นเป็นเหตุผลที่บางครั้งต้องปฏิบัติตามกฎของความเข้ากันได้แบบไบนารีย้อนหลัง

ฉันต้องการชี้ให้เห็นว่าปัญหายังมีอยู่ใน C.

คุณสามารถบอกคอมไพเลอร์ฟังก์ชั่นใช้การเรียกประชุมบางอย่าง หากคุณไม่คอมไพเลอร์จะต้องเดาว่ามันใช้หนึ่งเริ่มต้นซึ่งแตกต่างจาก C ++ ที่คอมไพเลอร์สามารถปฏิเสธที่จะรวบรวม

ตัวอย่างเช่น,

main.c

int main(void) {
  foo(1.0f);
  return 1;
}

foo.c

#include <stdio.h>

void foo(float x) {
  printf("%g\n", x);
}

บน Linux บน x86-64 ผลลัพธ์ของฉันคือ

0

หากคุณไม่ใส่ต้นแบบที่นี่คอมไพเลอร์จะถือว่าคุณมี

int foo(); // Has different meaning in C++

และแบบแผนสำหรับรายการอาร์กิวเมนต์ที่ไม่ระบุที่ต้องการนั้นfloatควรถูกแปลงเป็นdoubleให้ส่งผ่าน ดังนั้นแม้ว่าฉันให้1.0fคอมไพเลอร์จะแปลงมันจะผ่านมันไป1.0d fooและเป็นไปตามระบบวี Application Binary Interface AMD64 สถาปัตยกรรมเสริมตัวประมวลผลที่doubleได้รับผ่านใน 64 xmm0บิตอย่างมีนัยสำคัญน้อย แต่fooคาดว่าจะลอยและมันอ่านจาก 32 บิตที่สำคัญน้อยที่สุดxmm0และได้รับ 0