ตรวจสอบให้แน่ใจในเวลารวบรวมว่ามีการเรียกใช้เมธอดในที่เดียว

ฉันอยากรู้ว่าเป็นไปได้หรือไม่ที่จะมั่นใจได้ว่าในเวลารวบรวมว่ามีการเรียกใช้วิธีการในที่เดียว

โปรดทราบว่ามันก็โอเคถ้าฟังก์ชั่นถูกเรียกมากกว่าหนึ่งครั้ง (เช่นในลูป) - แต่มันไม่ควรถูกเรียกในลูปสองวงแยกกัน

สิ่งนี้สามารถแบ่งออกเป็นสองส่วนฉันยังสนใจในโซลูชันที่ครอบคลุมส่วนใดส่วนหนึ่ง:
(a) ตรวจสอบให้แน่ใจว่ามีการเรียกวิธีการอย่างน้อยหนึ่งแห่ง
(b) ตรวจสอบให้แน่ใจว่ามีการเรียกวิธีการในที่เดียว

ฉันสามารถควบคุมโครงสร้างของโค้ดได้อย่างเต็มที่และสำนวนต่าง ๆ ที่ได้รับแนวคิดเดียวกันก็ยินดีต้อนรับ

// class.h

class MyClass {
  public:
    void my_method();
}

ต่อไปนี้ไม่ควรรวบรวม (ไม่เคยเรียก)

#include "class.h"

int main() {
  MyClass my_class;
}

ข้อมูลต่อไปนี้ไม่ควรรวบรวม (เรียกมากกว่าหนึ่งแห่ง)

#include "class.h"

int main() {
  MyClass my_class;
  my_class.my_method();
  while(true) {
    my_class.my_method();
  }
}

ต่อไปนี้ควรรวบรวม (เรียกว่าในที่เดียว):

#include "class.h"

int main() {
  MyClass my_class;
  while(true) {
    my_class.my_method();
  }
}

แนวทางเทคโนโลยีต่ำ:

เนื่องจากคุณมีการควบคุมโครงสร้างรหัส (ซึ่งรวมถึงระบบการสร้างฉันถือว่า) นี่เป็นโซลูชั่นที่มีเทคโนโลยีต่ำ:

• ทำให้ชื่อฟังก์ชั่นไม่ซ้ำกันอย่างเพียงพอ
• grep สำหรับชื่อฟังก์ชั่นในรหัสของคุณ คุณคาดหวังสองครั้ง (สมมติว่าคุณมีการประกาศและคำจำกัดความ colocated):
  • ครั้งเดียวในส่วนหัว
  • ครั้งเดียวที่ไซต์การโทรเดียว

อีกวิธีหนึ่งคือ:

หากคุณต้องการแก้ไขด้วย C ++ จริงๆคุณสามารถลองได้

• ใช้ตัวนับเวลารวบรวมเพื่อคำนวณจำนวนการใช้ภายในหน่วยการรวบรวม
• ตรวจสอบให้แน่ใจว่าฟังก์ชั่นจะละเมิด ODR หากส่วนหัวรวมอยู่ในหลายหน่วยการรวบรวม

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

แต่จริงจัง:

อย่าทำอย่างนี้ ไม่ว่าคุณจะทำอะไรมันสามารถบิดเบือนได้โดยแทบไม่ต้องใช้ความพยายามจากฟังก์ชั่น wrapper:

auto call_my_method(MyClass& o)
{
   return o.my_method();
}

MyClass::my_method()เรียกว่าเฉพาะในเสื้อคลุม ทุกคนอื่นเพียงแค่เรียกเสื้อคลุมซึ่งอาจจะถูกขีดเส้นใต้โดยคอมไพเลอร์

ตามที่คนอื่นแนะนำ: มันอาจมีประโยชน์มากกว่านี้ถ้าคุณจะอธิบายว่าคุณพยายามทำอะไร

นี่เป็นแนวคิดคร่าวๆที่อาจใช้งานได้ (ยาวเกินไปสำหรับความคิดเห็น แต่ไม่สมบูรณ์สำหรับคำตอบ SO ที่ดี)

คุณสามารถทำได้โดยการนับ / ตรวจสอบอินสแตนซ์ของเทมเพลต
แม่แบบ instantiated เฉพาะเมื่อใช้งาน

ในทำนองเดียวกันแม่แบบวิธีการ / ฟังก์ชั่นร่างกายจะไม่แยกวิเคราะห์หรือรวบรวมหรือเชื่อมโยง ซึ่งหมายความว่าไม่มีการสร้างอินสแตนซ์ใด ๆ ภายในร่างกายของพวกเขา)

คุณอาจสร้างเทมเพลตที่รักษาจำนวนอินสแตนซ์โกลบอลและยืนยันแบบคงที่ (หรือกลไก TMP อื่น ๆ เพื่อตรวจสอบอินสแตนซ์ที่ผ่านมา)

มีคำตอบบางส่วนสำหรับคำถามนี้โดยใช้ตัวประมวลผลล่วงหน้า C และ GNU inline assembly:

ไฟล์ส่วนหัวa.h:

struct A {
    // Do not call this method directly, use the macro below to call it
    int _method_vUcaJB5NKSD3upQ(int i, int j);
};

// Use inline assembly to ensure that this macro is used at most once
#define method_vUcaJB5NKSD3upQ(args...) \
    _method_vUcaJB5NKSD3upQ(args); \
    asm (".global once_vUcaJB5NKSD3upQ; once_vUcaJB5NKSD3upQ:");

ไฟล์การใช้งานa.cc:

#include <iostream>
#include "a.h"

int A::_method_vUcaJB5NKSD3upQ(int i, int j) { return i+j+5; }

// Ensure that the macro is used at least once
extern "C" const char once_vUcaJB5NKSD3upQ;
static const char get_vUcaJB5NKSD3upQ = once_vUcaJB5NKSD3upQ;

int main() {
    A a;
    for(int i=0; i<7; i++) {
        // Use a separate statement to call the method
        // (terminated by a semicolon, it cannot be a sub-expression)
        auto x = a.method_vUcaJB5NKSD3upQ(2, 3);
        std::cout << x << std::endl;
    }
    return 0;
}

วิธีนี้มีบางส่วนในแง่ที่ว่ามันไม่ได้ป้องกันโปรแกรมที่เรียกวิธีการเริ่มต้นด้วยขีดล่างโดยตรงโดยไม่ต้องใช้แมโคร wrapper

ใช้ตัวนับ constexpr มีการนำไปใช้ในคำถามอื่น