ich benutze code::blocks.

bisher hab ich c-programme immer nur in einer datei entwickelt. jetzt würd ich den code mal aufteilen wollen, aber es geht nicht. das programm lässt sich nicht kompilieren.

habe 2 dateien: main.cpp (mit der mainfunktion) und die neu angelegte test.cpp (beide sind im source-ordner in code::blocks

inhalt der test.cpp:

namespace test
{
int truely()
{
    return 42;
}
};

jetzt möchte ich die funktion benutzen in der main:

int test::truely();

...

printf("%d\n",test::truely());

ich bekomm jedesmal " 'test' has not been declared" und " 'truely' was not declared in this scope"

jetzt weiß ich (zumindest denk ich mir das so), wird jede quellcode-datei in seine eigene *.o kompiliert, die dann mittels linker zur ausgabe zusammengefügt werden (korrigiert mich wenn ich falsch liege).
aber irgendwas fehlt noch. ich hab das gefühl ich muss dem irgendwie noch sagen (wenn er die main kompiliert), dass es die test.o gibt die er berücksichtigen muss.
ich bin n bischen verwirrt. kann mich da einer aufklären?

und wo wir grad dabei sind: dynamische bibliotheken. korrektes erstellen, verlinken und nutzen. das muss ich auch noch wissen. mit möglichst vielen details (z.b. will ich mittels singleton-pattern eine variable halten in einer dll. geht das überhaupt?)

vielen dank für eure hilfe

namespace test
{
int truely();
}

aber irgendwas fehlt noch. ich hab das gefühl ich muss dem irgendwie noch sagen (wenn er die main kompiliert), dass es die test.o gibt die er berücksichtigen muss.
ich bin n bischen verwirrt. kann mich da einer aufklären?

Das machst du mit forward declarations. Damit sagst du dem Compiler, dass die Funktion irgendwo anders existiert. Der Linker findet später heraus, wo genau.
Diese Sammlung an forward declarations kommt üblicherweise in eine Headerdatei (test.h), die du in main.cpp einbindest.

#include"truely.h"

int main(int argc,char* argv)
{
   test::truely();
return 0;
}

Die Headerdatei so:

#ifndef TRUELY_H_
#define TRUELY_H_
// Das sind die Inclusionguards, die verhindern, dass du den header mehrfach //einbindest (zusammen mit dem #endif)
namespace test // hoffe mal, das ist richtig

int truely();

#endif

und die Quelldatei so:

#include"truely.h"

int test::truely()
{
   return 42;
}

Mit namespace hab ich bis jetzt nicht groß rumjonglieren müssen, aber das kommt natürlich darauf an, was du damit machen willst.

athar hat bereits dafür gesorgt, dass mir ein licht aufgegangen ist

bleibt noch folgendes zu klären:

und wo wir grad dabei sind: dynamische bibliotheken. korrektes erstellen, verlinken und nutzen. das muss ich auch noch wissen. mit möglichst vielen details (z.b. will ich mittels singleton-pattern eine variable halten in einer dll. geht das überhaupt?)

zu meinen absichten: ich habe (erstmal) vor eine kleine (dynamische) bibliothek zu entwickeln, die ich später in einem größeren programm nutzn und parallel dazu weiterentwickeln möchte

...hoffe mal, das ist richtig...

Nicht ganz, der Namensraum muss die Funktion umschließen. Hier mal etwas anders:

// main.cpp
#include "truely.h"

int main()
{
    test::truely();
}

// truely.h, Ich habe mal den Namensraum in den Includeguard eingebaut.
#ifndef TEST__TRUELY__HEADER
#define TEST__TRUELY__HEADER

namespace test
{
    int truely();
}

#endif

// truely.cpp
#include"truely.h"

using namespace test; // Alternativ wie im Header

int truely()
{
   return 42;
}

zu meinen absichten: ich habe (erstmal) vor eine kleine (dynamische) bibliothek zu entwickeln, die ich später in einem größeren programm nutzn und parallel dazu weiterentwickeln möchte

Du solltest dabei nur Wissen, das keine Klassen ohne berücksichtig gewisser Einschränkungen über DLL-Grenzen hinweg austauschbar sind (Nach eigener Erfahrung, auch wenn mir jemand wiedersprochen hat, ist die DLL dann ggf. von der Compilerversion abhängig). DLLs gehören nicht zum C++ Standard, mit allen Konsequenzen daraus...

das ist so mein hauptproblem: ein teil der hardware-grundlagen und der konzeptionelle aufbau von größeren programmen.
wie man z.b. externe bibliotheken (eben als dll) einbindet, nutzt und das ganze dann wieder als bibliothek kompiliert und dass dann wieder woanders einbinden kann...
wäre auch schön, wenn da jemand ein literaturhinweis geben kann. also ein buch oder kapitel eines buches, welches sich genau damit befasst (bitte nicht die bücher auflisten die ihr kennt, sondern wirklich nur die, die sich damit auch befassen. bin gewillt mich da zu vertiefen, aber wenn man sich erst durch millionen wälzer kämpfen muss um bei der wichtigen information anzukommen verliert man das interesse).

vielen dank

wäre auch schön, wenn da jemand ein literaturhinweis geben kann. also ein buch oder kapitel eines buches, welches sich genau damit befasst

Sofern ich mich nicht irre, wird auf die Möglichkeit wie man Klassen über DLL-Grenzen übergeben kann in "Large-Scale C++ Software Design" (Addison Wesley) eingegangen (Kann ich aber derzeit nicht nachtesten, ich besitze zwar das Buch, habe aber das Buch aber relativ schnell wegen anderen Themen zur Seite gelegt.

Mein eigenes Wissen dazu ist schon älter und kann daher überholt sein (Letzter Test war unter Visual C++ 6.0 und Power++ 2.5), damals bin ich nach einer Beschreibung aus dem Internet gegangen, was aber im Endeffekt in dieser Compilerkonstellation nicht funktioniert hatte.

Eventuell ist ja auch eine Scriptsprache wie Lua für dich interessant. Damit kannst du dein Programm auch erweiterbar gestalten.

Ich persönliche nutze als Scriptengine Angelscript. Ist objektorientiert von haus aus und die Syntax ist C++ like.
rya.