C++: Friend-Methoden? Polymorphie nur über Zeiger? Arrays vs. Zeiger auf das erste Element?

Hallo zusammen,
ich habe beim Umziehen mein für meine Verhältnisse altes C++ Buch wiedergefunden. Hab überlegt mal reinzulesen, und fand es relativ interessant, vor allem weil ich inzwischen wirklich alles, was in C# nicht ist, vergessen habe. Zunächst fand ich die Erkenntnis sehr unterhaltsam, dass man mit dieser Sprache fast beliebig großen Mist in entsprechenden Mangen produzieren kann, und sogar das nur mit großem Aufwand. Bevor ein C++ Programierer sich jetzt beleidigt fühlt, ich meine Damit weniger den gelungenen(?) Übergang zur Objektorientierung(Sinn von Mehrfachvererbung etc.), sondern Sachen, mit denen man, wie in meinem Buch steht "im besten Fall einen Programmabsturz" erzeugt.(Verwendung gelöschter Zeiger, schreiben über Arrays hinaus, ähnliche Sachen mit referenzen, Speicherleaks etc.)
Allerdings kann ich es jedem reinen C# Programierer nur empfehlen etwas mehr über die Speicherverwaltung rauszufinden, was bei C++ notwendig ist, bei C# nützlich.(Meine Meinung)

ein Paar Dinge hab ich nicht kappiert.
Ich gedenke nicht mich jetzt viel damit zu beschäfftigen, also werde ich dafür nicht extra in ein C++ Forum gehen. Das werden mir sicher einige von euch genausogut erklären können.
Wenn man in der Klasse X die Klasse Y als Friend deklariert, erlaubt man Y auf die privaten Member von X zuzugreifen, oder?
Was soll aber die Sache mit den Friend methoden?

was mir weiterhin rätselhaft, bzw. nicht sinnvoll vorkommt, ist, dass C++ Polymorphie nur auf Zeigern (und Referenzen?) unterstützt, und dass ein Array und ein Zeiger relativ schwer auseinanderzuhalten sind- "ein Array ist ein konstanter Zeiger auf sein erstes Objekt" aber mir scheint, er merkt sich die Zahl seiner Objekte - er kann sie löschen

int main()
{
int* Werte=new int[3];
\*Werte=2; //erstes Objekt=2
\*(Werte+1)=3; //2. Objekt=3//geht das?

delete [] Werte; //er löscht alle, also muss er wissen, wie viele es sind.
                          //speichert er diese Anzahl irgendwo?

//und wenn ein Array ein Zeiger ist, ist ein Zeiger auch ein Array, oder?
int a=5;
int* pa=&a;
cout<<pa[0]; //geht das?
return 0;
}

Fehler sind nicht ausgeschlossen, da ich im neuen Visual C++ 2008 nicht mal "Hello World" hinkriege(er nimmt den cout<< Befehl nicht, obwohl iostream.h eingebunden ist). Das was IntelliSense anzeigt sieht mir sehr nach der .NET Bibliothek aus. (mit Event Handlern und so) Weiß jemand, wie man die Standart-C++ Bibliothek einstellt?

Hi

1. Friends:
   Ein Beispiel für friends ist, dass man bei für eine Klasse den Ausgabeoperator überläd. Es kann also durchaus sinnvoll sein, dass bestimmte Klassen/Methoden auf private Member zugreifen können.
   (Ein Code sagt mehr als tausend Worte:)

class A {
private: 
   int m_A;

  friend inline std::ostream & operator << 
		(std::ostream & stream, A const & a);
};
...
//.Cpp:
std::ostream & operator << (std::ostream & stream, A const & a){
   stream << "A: " << a.m_A;
   return stream;

//...
A a;
cout << a;
}

was mir weiterhin rätselhaft, bzw. nicht sinnvoll vorkommt, ist, dass C++ Polymorphie nur auf Zeigern (und Referenzen?) unterstützt

Das ist doch in C# auch nicht anders, nur dass hier bei Klassen immer gleich automatisch die Referenz gespeichert wird.

Die Anzahl der Elemente in Arrays weis ich auch nicht wo das beim allokieren im hintergrund gespeichert wird, man hat jedenfalls keine Möglichkeit darauf zuzugreifen.

int main()
{
int* Werte=new int[3];
\*Werte=2; //erstes Objekt=2
\*(Werte+1)=3; //2. Objekt=3//geht das? ... JA (stichwort Pointerarithmetik)

delete [] Werte; //er löscht alle, also muss er wissen, wie viele es sind.
                          //speichert er diese Anzahl irgendwo?

//und wenn ein Array ein Zeiger ist, ist ein Zeiger auch ein Array, oder?
int a=5;
int* pa=&a;
cout<<pa[0]; //geht das?   JA
return 0;
}

cout nimmt er nicht, da du den wahrscheinlich den std nicht eingebunden hast
also:

#include <iostream> //hier ohne .h

using namespace std;

int main () {

greets

gut, dann ist ja das soweit klar. Jetzt habe ich entdeckt, das am Anfang bei Neues Projekt die Möglichkeit besteht, zwischen Win32 und CRL auszuwählen(das wäre dann Managed C++, oder- igitt(nicht eigene Erfahrung, steht in meinem C# Buch))
edit:einiges gelöscht

wozu ist eigentlich das std-namespace da? in meinem Buch steht natürlich wieder ncihts davon.

edit: wie funktioniert der code mit dem friend Teil? Ihr könnt mich ruhig blöd nennen, kappier ich nicht.

achso, gut. Aber warum macht man den operator nicht einfach öffentlich?

Hab noch nicht ernstzunehmend mit Managed C++ gearbeitet, was ich aber bisher gesehen habe ist es wirklich eine Perversion.

Wie gesagt musst du die meisten Systemincludes ohne .h angeben
(Unter VisualStudioInsterlationsverzeichniss\VC\include sieht man auch, dass iostream, string, ... kein .h als Endung haben)

Hurra! Der Mist funktioniert!!!

	const int* pInt=0;
	int a=5;
	pInt=&a;
	
	for(int i=0;i<10;i++)
	{
		cout<<pInt[i]<<"\n";
	}

liefert

5
-858993460
-858993460
1245012
-858993460
1245112
4269240
1
3433112
3440168 

hoffentlich habe ich jetzt nicht meine Passwörter verraten, oder sowas 👅
(Ja, ich weiß, dass man damit nichts anfangen kann)

Zurück zum Ernst und nochmal zum Operator:
Fragen:

1. wieso erlaubt der Compiler eine <<-Methode mit 2 Argumenten in einer Klasse?
2. worauf verweist dann der this-Zeiger?
3. warum sollte der Operator private sein?
4. welche Klassen erhalten durch das friend Schlüsselwort in diesem Fall den Zugriff? der erste Parameter? der Rückgabetyp? Diese Frage muss unsinnig sein, oder?
   edit: 5. Wo ist der Operator implementiert? Der eine, nicht in der Klassendefinitione enthaltene hat ja forne kein A::-

1. Da der Operator hier in keiner Klasse ist wird ein Linkes und ein Rechtes Argument benötigt
   2/3/4 Der Operator hier ist ausserhalb einer Klasse -> kein this, er ist nicht private, nur die Methode (bzw. der Operator) erhalten zugriff.

2. Man könnte ihn in-Place Implementieren oder einfach auch mit ins Cpp file und halt ohne Classname::

Man könnte es mit einer extention Method von C# vergleichen, wo der std::stream um eine Überladung des << Operaors erweitert wird und der Parameter stream quasi das this bei der extention Method wäre.

stdostream & operator << (stdostream & stream, A const & a)

A a1, a2;

  cout  <<   a1 << a2;
//  |         |     |
//stream      a     |
//\___________/     |
//         |        |
//       stream     a

greets

PS:

  
  const int* pInt=0;  
  int a=5;  
  pInt=&a;  
    
  for(int i=0;i<10;i++)  
  {  
  	cout<<pInt[i]<<"\n";  
  }  

Ich hoffe dir ist klar das du damit schon zwangsläufig eine Zugriffsverletzung hast.

Ein Array muss nicht zwingend ein Pointer sein.

char blubb[100];

wäre zum Beispiel ein char Array der größe 100. Das mit den Pointern macht man nur, damit man die Größe variabel halten kann.

Drei Anmerkungen.

a) Die Frage Array / Pointer ist keine C++-Frage, sondern eine von ANSI-C.
b) C-Arrays sind keine Pointer, Punkt. (Allerdings erlaubt ANSI-C das behandeln von Array-Referenzen als Referenzen auf Pointer, und in gewissen Kontexten verhalten sie sich tatsächlich absolut gleich. Allerdings funktionieren die Lookups für die gehaltenen Werte unterschiedlich.