Найти нереализованные методы класса

Хотя я не вижу простого способа сделать это без фактической попытки связать, вы можете grep вывод компоновщика для «неопределенной ссылки на ClassInQuestion::», что должно дать вам только строки, связанные с этой ошибкой для методов данного класса .

Это, по крайней мере, позволяет избежать просеивания всех сообщений об ошибках всего процесса компоновки, хотя и не избавляет от необходимости проходить полную компоновку.

Вы можете добавить заглушку для каждого метода, который вы собираетесь реализовать, и сделать:

void SomeClass::someMethod() {
    #error Not implemented
}

С gcc это выводит файл, номер строки и сообщение об ошибке для каждого из них. Таким образом, вы можете просто скомпилировать рассматриваемый модуль и выполнить grep для «Не реализовано», не требуя запуска компоновщика.

Хотя вам все равно нужно добавить эти заглушки в файлы реализации, которые могут быть частью того, что вы пытались обойти в первую очередь.

Вот для чего нужны юнит-тесты и инструменты тестового покрытия: заранее напишите минимальные тесты для всех функций. Тесты на отсутствующие функции не будут связаны. Отчет о тестовом покрытии сообщит вам, все ли функции были посещены.

Конечно, это только помогает до некоторой степени, это не 100% защита от дурака. Ваша методология разработки кажется мне несколько хитрой: разработка классов один за другим в изоляции не работает на практике: классы, которые зависят друг от друга (и помните: уменьшите зависимости!), должны быть разработаны в некоторой степени синхронно. Вы не можете создать полную реализацию для одного класса и перейти к следующему, никогда не оглядываясь назад.

В прошлом я создал исполняемый файл для каждого класса:

#include "klass.h"
int main() {
    Klass object;
    return 0;        
}

Это сокращает время сборки, позволяет вам сосредоточиться на одном классе за раз, ускоряет цикл обратной связи.

Его можно легко автоматизировать.

Я действительно хотел бы уменьшить размер этого класса!

изменить

Если есть препятствия, вы можете использовать грубую силу:

#include "klass.h"

Klass createObject() {
    return *reinterpret_cast<Klass>(0);
}    

int main() {
    Klass object = createObject();
    return 0;        
}

Вы можете написать небольшой скрипт, который анализирует заголовочный файл на наличие реализаций методов (регулярные выражения упростят эту задачу), а затем сканирует файл реализации на наличие тех же реализаций методов.

Например, в Ruby (для модуля компиляции C++):

className = "" # Either hard-code or Regex /class \w+/
allMethods = []

# Scan header file for methods
File.open(<headerFile>, "r") do |file|
    allLines = file.map { |line| line }
    allLines.each do |line|
        if (line =~ /(\);)$/) # Finds lines ending in ");" (end of method decl.)
            allMethods << line.strip!
        end
    end
end

implementedMethods = []
yetToImplement = []

# Scan implementation file for same methods
File.open(<implementationFile>, "r") do |file|
    contents = file.read
    allMethods.each do |method|
        if (contents.include?(method)) # Or (className + "::" + method)
            implementedMethods << method
        else
            yetToImplement << method
        end
    end
end

# Print the results (may need to scroll the code window)
print "Yet to implement:\n"
yetToImplement.each do |method|
    print (method + "\n")
end

print "\nAlready implemented:\n"
implementedMethods.each do |method
    print (method + "\n")
end

Кто-то еще сможет рассказать вам, как автоматизировать это в процессе сборки, но это один из способов быстро проверить, какие методы еще не реализованы.

Ключевое слово delete С++ 11 делает свое дело

struct S{
  void f()=delete; //unimplemented
};

Если С++ 11 недоступен, вы можете использовать private в качестве обходного пути.

struct S{
  private: //unimplemented
  void f();
};

С помощью этих двух методов вы можете написать тестовый код в файле .cpp.

//test_S.cpp
#include "S.hpp"
namespace{
  void test(){
    S* s;
    s->f(); //will trigger a compilation error
  }
}

Обратите внимание, что ваш тестовый код никогда не будет выполнен. Пространство имен{} говорит компоновщику, что этот код никогда не используется вне текущей единицы компиляции (т. е. test_S.cpp) и поэтому будет удален сразу после проверки компиляции.

Поскольку этот код никогда не выполняется, вам фактически не нужно создавать реальный объект S в тестовой функции. Вы просто хотите обмануть компилятор, чтобы проверить, есть ли у объектов S вызываемая функция f().

Вы можете создать собственное исключение и выдать его так, чтобы:

• Вызов нереализованной функции завершит приложение, а не оставит его в неожиданном состоянии.
• Код все еще может быть скомпилирован, даже без реализации необходимых функций.
• Вы можете легко найти нереализованные функции, просмотрев предупреждения компилятора (используя некоторые, возможно, неприятные приемы) или выполнив поиск в каталоге вашего проекта.
• При желании вы можете удалить исключение из выпускных сборок, что приведет к ошибкам сборки, если есть какие-либо функции, которые пытаются генерировать исключение.

#if defined(DEBUG)

#if defined(__GNUC__)
#define DEPRECATED(f, m) f __attribute__((deprecated(m)))
#elif defined(_MSC_VER)
#define DEPRECATED(f, m) __declspec(deprecated(m)) f
#else
#define DEPRECATED(f, m) f
#endif

class not_implemented : public std::logic_error {
public:
    DEPRECATED(not_implemented(), "\nUnimplemented function") : logic_error("Not implemented.") { }
}

#endif // DEBUG

Нереализованные функции будут выглядеть так:

void doComplexTask() {
    throw not_implemented();
}

Вы можете искать эти нереализованные функции несколькими способами. В GCC вывод для отладочных сборок:

main.cpp: In function ‘void doComplexTask()’:
main.cpp:21:27: warning: ‘not_implemented::not_implemented()’ is deprecated: 
Unimplemented function [-Wdeprecated-declarations]
     throw not_implemented();
                           ^
main.cpp:15:16: note: declared here
     DEPRECATED(not_implemented(), "\nUnimplemented function") : logic_error("Not implemented.") { }
                ^~~~~~~~~~~~~~~
main.cpp:6:26: note: in definition of macro ‘DEPRECATED’
 #define DEPRECATED(f, m) f __attribute__((deprecated(m)))

Релизные сборки:

main.cpp: In function ‘void doComplexTask()’:
main.cpp:21:11: error: ‘not_implemented’ was not declared in this scope
     throw not_implemented;
           ^~~~~~~~~~~~~~~

Вы можете искать исключение с помощью grep:

$ grep -Enr "\bthrow\s+not_implemented\b"
main.cpp:21:    throw not_implemented();

Преимущество использования grep заключается в том, что grep не заботится о вашей конфигурации сборки и все равно найдет все. Вы также можете избавиться от устаревшего квалификатора, чтобы очистить вывод вашего компилятора — вышеописанный хак генерирует много ненужного шума. В зависимости от ваших приоритетов это может быть недостатком (например, вы можете не заботиться о функциях, специфичных для Windows, если в настоящее время реализуете функции, специфичные для Linux, или наоборот).

Если вы используете IDE, большинство из них позволит вам выполнять поиск по всему проекту, а некоторые даже позволяют щелкнуть правой кнопкой мыши символ и найти его везде, где он используется. (Но вы сказали, что не можете его использовать, поэтому в вашем случае grep — ваш друг.)

Я не вижу простого способа сделать это. Наличие нескольких классов без реализации легко приведет к ситуации, когда отслеживание в команде с несколькими членами станет кошмаром.

Лично я хотел бы проводить модульное тестирование каждого класса, который я пишу, и я рекомендую разработку через тестирование. Однако это требует связывания кода каждый раз, когда вы хотите проверить статус. Инструменты для использования TDD см. по ссылке здесь.

Другой вариант — написать фрагмент кода, который может анализировать исходный код и проверять, какие функции должны быть реализованы. GCC_XML — хорошая отправная точка.