✔ Wie included ihr?

Autsch, sowas musst aber im Schlaf beherrschen genau so wie die Operatoren.
Lerne bitte unverzüglich alle Zugriffsmodifikatoren und deren Funktionsweise auswendig.
Zum Vergrößern anklicken....
*g* Grosses Missverständnis *g*
Ich dachte, es gibt da noch eine "andere" Verwendung von public.
Ein "public ref class" macht ja eben eine Klasse auch in anderen Assemblies bekannt. So dachte ich mir das eben mit obigem Beispiel auch. Ansonsten sind mir public, private, protected schon klar :D In .net ist einfach noch mehr... das verwirrt mich noch etwas.
 
Macan hat gesagt.:
Und das public dort (mal sehen, ob das in C++ genauso ist) macht die dann quasi sichtbar? Ich dachte mir, dass public in dem Zusammenhang nur heisst, dass auch andere Assemblies Zugriff haben können. Aber - so oder so - wieder was gelernt :)
Zum Vergrößern anklicken....
public, private, protected und friend regeln den Zugriff auf Funktionen, Klassen, Properties,...etc...
mehr dazu in der MSDN -> :suchen:

Macan hat gesagt.:
Also so ist da nichts einzubinden. Geht wohl nur, wenn man eben eine .exe oder .dll hat. Assemblies basteln (also .dll's)... soweit bin ich noch nicht *g* Eine .exe und die Sprachresourcen in .dll sind bis jetzt das höchste der Gefühle :D
Zum Vergrößern anklicken....
Ach, das kommst schon noch ^^

Macan hat gesagt.:
Nur mit den namespaces, das scheint noch nicht so zu wollen. Also wenn ich nur Sourcecode habe, dort eben in jeder .h (und zugehörigen .cpp Datei) die namespaces definiere... also:
Datei Foo.h
Code: 
namespace Foo
{
code... (Definitionen, Methoden, etc.)
}
dann benötige ich nur noch die namespaces, also:
Datei Bar.h
Code: 
using namespace Foo;
und alles wird gut? #include Foo ist dann nicht mehr nötig? Ich frage, weil das bei mir nicht funktioniert.
Zum Vergrößern anklicken....
Also ich würde das mal folgendermaßen machen:
C++: 
// test.cpp file
//==========
// hier kommen die ganzen Methoden rein
// immer mit namespace::Klasse::Name

#include "test.h"
using namespace Test;

Test::test::test()  // Konstruktor
{
     InitializeComponent();
}

//oder:
void Test::test::InitializeComponent(void)
{
     this->Counter = 5;  // ruft Property Test::Counter::set(5) auf
}


// dazugehöriges test.h file
//==================
# pragma once

using namespace System;
using namespace System::Reflrection;
using namespace System::Drawing;
...

namespace Test
{
     public ref class test
     {
          // members
          private:
               int m_count;

          public:
          //Prototypen für Funktionen
               test();  // Konstruktor

               void initialize Component(void);

          // properties:
          property int Counter
          {
               int get ()
               {
                    return this->m_count
               }
               void set (i_value)
               {
                    this->m_count = i_value;
               }
          }
     };
}
der Code ist aber nicht getestet sondern eher als Pseudo Code anzusehn, werde aber heute im Laufe des Tage noch eine kleine Demo machen :)

Du includest also immer in den .cpp files die dazugehörigen Header und in denen kümmert du dich um die namespaces
klar soweit?

mfG
der incredible Leitman ^^

PS: AYBABTU


EDIT: Also JETZT habe ich komplett abgeloost -.-
in der Zeit in der ich auf einen Beitrag antworte, schreiben schon 2 weiter ^^ *loool*

Michael, mach Markus doch bitte mal eine kleine Demo dazu.
Ich denke dann wird sich auch noch das Problem schnell lösen
Zum Vergrößern anklicken....
Ja, ich wollte eh schneller sein XD
 
Zuletzt bearbeitet:
leitman hat gesagt.:
Dafür kann ich aber mit dem integrierten Windows Designer wundervolle Forms und Controls erstellen :P :D
Zum Vergrößern anklicken....
Wow, dafür bekommst du einen GUID von mir geschenkt :p

Und für deine C++++ Grafik bekommst du gleich noch einen :D

Bezüglich dem zurückfallen nach C mach dir keine Sorgen Macman.
Mir passiert es auch noch oft dass ich
Code: 
Console.printf("%d", x);
schreibe :D

macman hat gesagt.:
Ansonsten sind mir public, private, protected
Zum Vergrößern anklicken....
... internal hast du vergessen :D

So, genug Klugshicerei ... ich bleib bei C#, C++ is mir zu verwirrend :)

Damit der Post nicht ganz unnötig ist, noch eine Frage:
#include in c++ ist dasselbe wie using in c#, richtig?
Obwohl ... eigentlich ne, weil man in C++ ja auch using nutzen kann... Hm :confused:

PS: Warum gibts in C# keine Präprozessordirektiven mehr?
 
Zuletzt bearbeitet:
leitman hat gesagt.:
public, private, protected und friend regeln den Zugriff auf Funktionen, Klassen, Properties,...etc...
Zum Vergrößern anklicken....
Das hab ich drin :D Mit den Properties eben nur noch nicht. Also innerhalb einer Klasse definiere ich ein Property auch public:, sonst macht das ja wenig Sinn. Darüber reiche ich dann ja auch z.B. von einem Objekt Daten, Referenzen, etc. in andere weiter. Ich wusste nur nicht, ob das auch OOP verträglich ist (sieht für mich so nach c und Pointern aus :D)
Und will ich "friend" in ref class verwenden, dann mag das der Compiler leider auch nicht. Aber er wird schon seine Gründe dafür haben. Wurde vielleicht als Kind nicht lange genug gestillt ;)

Du includest also immer in den .cpp files die dazugehörigen Header und in denen kümmert du dich um die namespaces
klar soweit?
Zum Vergrößern anklicken....
Sowieso. Das mache ich auch so.

Code: 
Codebeispiel...
Komisch - genauso mache ich das auch. Nur wenn ich dann in einer anderen .h Datei einen, so definierten, namespace verwenden will, dann sind Intellisense und Compiler da ganz anderer Meinung *g*
Aber ich gehe davon aus, dass Du
Code: 
Test::test::test()
meintest, oder (nur wegen dem MyTest).

Und so sollte ich dann einfach mit
Code: 
using namespace Test;
in jeder anderen .h (und .cpp) Datei auf die entsprechenden Klassen, etc. zugreifen können. Klingt auch logisch nur funktioniert bei mir nicht - ich muss irgendwie wirklich mal ausmisten *g*

nil18 hat gesagt.:
Bezüglich dem zurückfallen nach C mach dir keine Sorgen Macman.
Zum Vergrößern anklicken....
Ich sage nur: "Wehret den Anfängen" :D

Und stimmt - internal - das ist auch für den Zugriff von anderen Assemblies aus gedacht, soweit ich gelesen habe.

Also ich sollte mal sehen, wo es bei mir im VS hakelt. Irgend etwas läuft da unrund. namespaces könnten doch so schön sein :)

EDIT: Wer ist AYBABTU?
Ach und - using müsste #include sein. Denke ja
 
Zuletzt bearbeitet:
Macan hat gesagt.:
EDIT: Wer ist AYBABTU?
Zum Vergrößern anklicken....
All your base are belong to us ^^

ich habe eine kleine unbedeutende Demo angefügt, in der eine Klasse aus einem Namespace auf ein Property einer anderen Klasse in einem zweiten namespace zugreift

mfG
Leitman

PS: Warum gibts in C# keine Präprozessordirektiven mehr?
Zum Vergrößern anklicken....
Gibts micht mehr ?
#if, #define, #pragma,... gibts alles ==> MSDN: preprocessor directives
 

Anhänge

Zuletzt bearbeitet:
AYBABTU - gefällt mir :D

Ich habe mal ein neues Projekt erstellt, nur um sicher zu gehen. Das wollte ich gerade mal posten (denn es funktioniert einfach nicht).

ich habe eine kleine unbedeutende Demo angefügt, in der eine Klasse aus einem Namespace auf ein Property einer anderen Klasse in einem zweiten namespace zugreift
Zum Vergrößern anklicken....
Super :) Dann sehe ich mir die gleich an und poste dann, was ich hier gebastelt habe :)
Und... unbedeutend... wenn das funktioniert, dann ist das vielleicht der entscheidende Schritt auf dem Weg zur Weltherrschaft (frei nach Brain :D).
 
Wow - tausend Wege führen nach Rom :)
Also das mit dem Property habe ich verstanden (*notiert* noch ein bisserl dezentraler arbeiten). Das Event könnte man ja, anstelle von Form, gleich von der richtigen Event-Klasse ableiten, oder gibt es da noch einen Unterschied? Na aber das soll ja jetzt nicht so ins Detail gehen - hab ich so verstanden und auch so gemacht (nur dennoch sehr lehrreich, da ich dann das Property gleich direkt in Form1 integriert hätte, Dein Beispiel ist besser, spart man wieder ein paar Ebenen und ich bis jetzt nichts über main() definiert hatte - ausser eben ein #include).

Nur mit den Namespaces, Headern, etc. Da mache ich alles schon genauso und somit helfen mir die nicht weiter. Man kann die namespaces nur nutzen, wenn man auch die entsprechende Header-Datei included und das ist ja das Problem. Also heisst es da einen Umweg gehen und umstrukturieren. Naja ist auch Übung :D
Ich dachte mir, ich mache da mit den Referenzen, Properties, etc. einen Umweg. Dabei muss das so sein - na immerhin weiss ich nun, dass es so richtig ist (also vom OOP Standpunkt aus gesehen).

Ich danke Dir für Deine Mühe und stürze mich gleich mal rein :D

EDIT: Hehe - der Hype ist an mir vorüber gegangen :D Gleich mal nachholen *g* AYBABTU
 
Zuletzt bearbeitet:
Nabend!

internal gewährt den Zugriff von "überall", innerhalb der aktuellen Assembly!

Tatsächlich, Präprozessordirektiven in C# ... cool, wusst ich gar net. Hab aber auch nicht gesucht :D

How are you gentlemen? Main screen turn on! Take off every zig! Muahaha :)

Man kann die namespaces nur nutzen, wenn man auch die entsprechende Header-Datei included und das ist ja das Problem. Also heisst es da einen Umweg gehen und umstrukturieren. Naja ist auch Übung
Ich dachte mir, ich mache da mit den Referenzen, Properties, etc. einen Umweg.
Zum Vergrößern anklicken....
*hust* Interface *hust*

... Und viel Spass bei der Weltherrschaft!
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück