How to check if every declared class function is implemented

Question

UPDATE2: Why everybody downvotes this but no one explains why complier does not complains this problem but chatter at a unused variable. It's like a C++ bug.

UPDATE3: It seems possible using G++ with nm function to compare

Below is a one minute sketch for a simple comparison(just a proven of concept)

~/testcpp> cat a.cpp
class foo {
        public:
                foo();
                foo(int);
};

foo::foo(int i){
}
int main(){
        return 0;

}

~/testcpp> g++ -std=c++0x -c a.cpp

~/testcpp> g++ -E a.cpp | perl -ne 'push @x,$_ if /class foo/../};/;END{@x=map {"foo::$_" } grep {/\);/} map{s/[ \t]*//g;$_}@x;print @x}' | tee head.txt
foo::foo();
foo::foo(int);

~/testcpp> nm -C a.o | grep foo:: | cut -b'20-' | uniq | tee body.txt
foo::foo(int)

~/testcpp> diff head.txt body.txt
1,2c1
< foo::foo();
< foo::foo(int);
---
> foo::foo(int)
~/testcpp>

~~~~~~~~~~~~~~~~~~~~

Original question: I noticed some of my declared class functions are not defined, since my project is a module. It's found by the user later on.

Is there any method(or function in VC++) to do the integrity check?

UPDATE: To be more specific:

#include "stdafx.h"
class foo{
public:
    void aaa();   //<---This function is not defined and no warnings
};

int _tmain(int argc, _TCHAR* argv[])
{
    return 0;

}

Why C++ can find a "defined but unused variable", but not able to find a "declared but undefined function"?

My Opinion:

it seems there are some decorations for DLL function in VC++ so the compiler knows about the function is implemented somewhere else. By using static lib with own code or external code, the linker shall be able to traverse all symbols and find the missing.

Update:

By reading Peter's answer I can accept the fact that linker does not do the job. But my opinion is unit test is not for this task. the symbol check is kind of string compare, not at function check level yet. May I ask one more question, can I export the symbol tables and do some string check. 5-10MB binary file(maybe smaller when exported to tables) is not a heavy task for scripts using regular expression tools

Thanks.

Answer 1

Some compilers sometimes do. Try this:

static int f();

then don't define it.

The reason the compiler can diagnose this is that static int f() declares a function that can only be used in the current translation unit and, further, can only be defined in the current translation unit. That's like declaring a local variable and not using it.

Both of these are different from declaring an external variable that isn't used; it could be defined in some other translation unit, but since it's not used, why put in the extra effort to figure that out? Recognizing it would require putting information about every function declaration into every object file, and then having the linker check that information. You really don't want to have unused declarations of every function in the standard library stuffed into each of your object files just so the linker can tell you that you didn't use most of them.

As others have said, the way to detect this is to write unit tests. Which you should be doing anyway, so this check comes for free.

Answer 2

you're missing the point. If you created a module/plugin/library with some methods/functions, C++ has no way to know who/where/how will use your library.

It's not a problem of your library, it's a problem of caller software.

If you're developing some, say "server/main app" and want to be sure that plugins have functions they declare, you should go level up - and test if your main application can be linked against your plugin. C++ has nothing to do with this process by itself.

p.s. before crying about c++ bugs, google://"linker c++" or something like this.

Answer 3

Declared-undefined function are perfectly allowed for many reasons. First, sometimes the programmer would want to declare the function and define it in another file (have definitions in .hpp for example and implementations in .cpp the files). The application will only look for an implementation - if its used - during the linking stage. Second, sometimes implementations of functions are put in dlls (in case its windows), and that can be quite convenient.

Answer 4

Updated the answer with something that may have more promise.

---

Sorry this is not a full answer, but I wanted to get something to you...

---

To begin, @Pete Becker has the best answer pertaining to why C++ does not throw warnings. So, this answer will mainly attempt to give you some kind of direction to get all of the undefined functions.

---

Getting Def Methods

I have found the following command to produce an output of all of the functions within a given .o file that have a definition. It does include the namespaces, but this is not designed to be the whole solution.

nm -C <object file> | grep '(.*)' | grep -oP '(?<= \w ).*'

The first grep just returns all of the lines that contain functions, then the second actually grabs the functions.

---

First Attempt

Combining this with some Python I was able to produce the following:

import os
import re

def getDefMethods(object_file):
    file = os.popen("nm -C %s | grep '(.*)' | grep -oP '(?<= \w ).*'"%object_file)
    lines = file.readlines()
    result = []

    for i in lines:
        # Removes the namespaces to some degree...
        result.append(re.search("([^\:]*\(.*\))", i).groups[0])
    return result

def getMethods(header):
    file = open(header, 'r')
    lines = file.readlines()
    result = []

    for i in lines:
        match = re.search(".*\s(\w*\(.*\))", i)
        if match != None:
            result.append(match.groups()[0])
    return result

def getUndMethods(object_file, header):
    defs = getDefMethods(object_file)
    fs = getMethods(header)
    result = []

    for i in fs:
        found = False
        for j in defs:
            if i == j:
                found = True
                defs.remove(j)
                break
        if not found:
            result.append(i)
    return result

---

Disclaimer

Now, this is not a full solution that handles everything you can throw at it nor is this the fastest, but it does give you a good starting point. (This applies to the update as well.)

---

Update

Found the library CastXML that takes C++ and spits out an XML file pertaining to the code.

Using that and an XML parser in Python I came up with the following that should handle a lot more cases.

import os
import xml.etree.ElementTree as ET

def_methods = []
all_methods = []
und_methods = []

def getDefMethods(object_file):
    file = os.popen("nm -C %s | grep '(.*)' | grep -oP '(?<= \w ).*'"%object_file)

    result = file.readlines()
    result = [line.rstrip('\n') for line in result]
    def_methods.extend(result);

    return result

def getID(root, id):
    if id != None:
        for elem in root.iter():
            if elem.get('id') == id:
                return elem
    return None

def buildNamespace(root, elem, first):
    if elem == None or elem.get('name') == "::":
        return ""

    id = None
    if elem.get('context') != None:
        id = elem.get('context')
    elif elem.get('type') != None:
        id = elem.get('type')

    if first:
        namespace = elem.get('name')
    else:
        namespace = elem.get('name') + "::"

    namespace = buildNamespace(root,getID(root,id),false) + namespace
    return namespace

def buildArgs(root, function):
    result = "("
    args = function.findall('Argument')
    for arg in args:
        name = arg.get('name')
        type = buildNamespace(root, getID(root,arg.get('type')),true)
        result += type + " " + name + ", "
    if result.endswith(", "):
        result = result[:-2]
    return result + ")"

def getMethods(file_name):
    xml = "%s.xml"%file_name
    os.system(("gccxml %s.cpp -fxml="%file_name) + xml)

    result = []
    tree = ET.parse(xml)
    root = tree.getroot()

    functions = root.findall('Function')

    for function in functions:
        f = function.get('name')
        f += buildArgs(root,function)
        f = buildNamespace(root,getID(root,function.get('context')),false) + f
        result.append(f)

    methods.extend(result)

    return result

def getUndMethods(object_file, file_name):
    defs = getDefMethods(object_file)
    fs = getMethods(file_name)
    result = []

    for i in fs:
        found = False
        for j in defs:
            if i == j:
                found = True
                defs.remove(j)
                break
        if not found:
            result.append(i)
    und_methods.extend(result)
    return result

---

Example

import test as methodFinder

methodFinder.getUndMethods("a.o", "a")

print "All Methods defined in object file\n"
for method in methodFinder.def_methods:
    print method, "\n"
print "All Methods in file\n"
for method in methodFinder.methods:
    print method, "\n"
print "Undefined Methods\n"
for method in methodFinder.und_methods:
    print method, "\n"

NOTE: I have not had the time nor the environment to test the above code. So, if you find a stupid please attempt to fix it. Also, I know that is bad that the code has not been tested, but I wanted to give you something that I am pretty confident will handle a lot of methods.

---

Hope this helps!