Wie erstellt man eine Klasse und greift dann auf deren Objekte zurück?

dixidix

Sicherlich für die meisten banal, aber ich blicke da nicht so recht durch.
Also zur Sache:
Ich habe ein Projekt bestehend aus meheren Dateien (cpp und header). Ich möchte nun in einer dieser Files eine Klasse bereitstellen.
Als schematisches Beispiel dafür habe ich hier eine Headerdatei:
mytools.h

#ifndef _mytools_h
#define _mytools_h

class CmyTools
{

	public:
		int getmyMode();

};

#endif
class CmyTools;

und hier die cpp:
mytools.cpp

#include "mytools.h"

using namespace std;

int CmyTools::getmyMode()
{	
        int x = 1
	return x; 
}

Wie kann man nun in einer Weiteren Datei auf diese Klasse zurückgreifen und die Funktion getMyMode() nutzen?

Spontan würde ich das ja so machen:
test.h

#include <mytools.h>

test.cpp

#include "test.h"

int main
{

	cout<<CmyTools.getMyMode()<<endl;
}

Kann mir das jemand nachvollziebar erklären, evtl. an dem Beispiel, wäre toll?!

Maxi

du musst dir eine instanz deiner klasse erstellen

also:

CmyTools mt;
cout << mt.getmode();

oder du machst die funktionen statisch, dann kannst du mit

cout << Cmytolls::getmode();

draufzugreifen. Allerdings hast du dann keine instanz in der du spezifische daten speichern kannst

*D*Evil

myTools.h

#if !defined(MY_TOOLS_H__INCLUDED)
#define MY_TOOLS_H__INCLUDED

class myTools
{
    myTools(void) : m_Variable(10) {}

public:
    unsigned short& getVariable(void) { return m_Variable; }
    static unsigned short getStaticValue(void) { return 10; }

private:
    unsigned short m_Variable;
};

#endif // MY_TOOLS_H__INCLUDED

test.h

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

test.cpp

#include "test.h"

int main()
{    
    std::cout << myTools::getStaticValue() << std::endl;
    myTools instance;
    std::cout << instance.getVariable() << std::endl;
    return 0;
}

... selbst erklärend ^^

dixidix

Danke erstmal für die Info, da ist mir aber noch einiges unklar.
Das das so aufwendig ist kann ich nicht so ganz nachvollziehen:

class myTools
{
    myTools(void) : m_Variable(10) {}// was bedeutet diese Zeile,
                                     // wozu werden hier geschweifte Klammern benötig

public:
    unsigned short& getVariable(void) { return m_Variable; } // auch hier, was sollen diese {} bewirken
    static unsigned short getStaticValue(void) { return 10; } //und hier

private:
    unsigned short m_Variable;
};

Ginge das nicht auch so?
Ist sowas richtig?

info.h

class CInfo
{
public:
    std::string getInfo();

private:
    std::string strinfo;
};

info.cpp

#include <string>
std::string CInfo::getInfo()
{
	CInfo::strinfo = "$testtext$";
	return CInfo::strinfo;
}

dann der Aufruf in einem anderen Programmteil:

irgendwo.cpp

#include <info.h>

main ()
{
 CInfo instance;
  i = instance.getInfo();
  cout<<i<<endl;
}

*D*Evil

hmm ... müsstest de eigentlich kennen. Zwischen { und } steht die Definition der Funktion ... nur anstelle das ich das in nen extra Source-File gepackt hab, steht es direkt mit im Header ... bei so kurzen Getter bzw Settern ist das kein Problem ...

dixidix

müsstest de eigentlich kennen

Noch nicht so ganz, da ich mich damit noch nicht so richtig auskenne, aber ich hoffe, es noch zu kappieren...deswegen frag' ich ja und es wäre für mich einfacher wenn man das irgendwie Stück für Stück nachvollziebar erklärt bekommt. Es gibt zwar eine Menge Tutorials, die ich mir schon angesehen habe, aber irgendwie mir nicht so recht weitergeholfen haben, da viele davon nicht ganz newbiegerecht ausgerichtet sind.

*D*Evil

Naja ist eigentlich fast das gleiche wie:

#if !defined(MY_TOOLS_H__INCLUDED)
#define MY_TOOLS_H__INCLUDED

class myTools
{
    myTools();

public:
    unsigned short& get_variable();
    static unsigned short get_static_value();

private:
    unsigned short m_Variable;
};

#endif // MY_TOOLS_H__INCLUDED

und

#include "my_tools.h"

myTools::myTools() : m_Variable(10)
{
}

unsigned short& myTools::get_variable()
{
    return m_Variable;
}

unsigned short myTools::get_static_value()
{
    return 100;
}

...