Hi,

Folgendes stark reduziertes Beispiel:

int func (const int i) {

return i*2;

}

template struct templ {

static T work(const T a, const T b) {

return a + op(b);

}

};

int main() {

return templ::work(1,2);

}

Ich möchte nun dem Nutzer des Templates ersparen, den Parameter T

jedesmal mitangeben zu müssen[1], da er sich ja aus dem übergeben
en

Funktionszeiger ergibt. Gibt es irgendeine Möglichkeit, das in halbwegs

unhäßlich hinzukriegen?

Danke,

Hi,

ich habe vor kurzem ein Grundlagentutorial über C++ auf meiner Homepage
veröffentlicht. Ich denke dies könnte für den ein oder anderen ganz
interessant sein. Reinschauen lohnt sich. ;-)

Das Tut gibt es unter der Adresse:

http://midgardnet.mi.funpic.de/wwwroot/index.php/tutorials/grundlagen-c

Mit freundlichen Grüßen,

midgard

Hi NG,

ab und zu macht mir Folgendes Sorgen:
Ich habe ein Array a[x_var][c_const] (x_var = steht erst zur Laufzeit fest)
und ich brauche dynamisch Speicher dafür.

Momentan schaffe ich das nur mit einem typedef zu lösen. Wie macht man es
aber richtig?

typedef char CHARPATH[_MAX_PATH];
CHARPATH* szSrcPath = new CHARPATH[nNumPaths];

for(int i = 0; i < nNumPath; i++)
{
strcpy(szSrcPath[i], saAttachmentSrcFiles.GetAt(i));
}
...

Ich möchte mit i auf die einzelnen Strings zugreifen können.

Vielleicht in etwa so:
char* szSrcPath[_MAX_PATH] = new char[nNumPaths][_MAX_PATH]; ?????

Danke für Eure Hilfe.

Sven

Hallo,

ich habe ein Problem mit boost::spirit. Zum einen ist er gierig und zum
anderen gibt er nichts zurück, was er mal hat.

Ich möchte SIP-Messages parsen. Der Aufbau wird in RFC3261 beschrieben.
Dabei gibt es z.B. folgende Zeile:

INVITE sip:bob@biloxi.com SIP/2.0

Wenn man jetzt mal nur die E-Mail-Adresse betrachtet, sagt die BNF dazu:
...
SIP-URI = "sip:" [ userinfo ] hostport
uri-parameters [ headers ]
SIPS-URI = "sips:"...

Hallo,

in einem Beispiel (GNU g++ unter Linux, g++ 4.1.2) habe ich eine Klasse
Base und jeweils davon abgeleitet DerivedA und DerivedC.

Ich instanziiere dynamisch ein Base* als entweder Base, DerivedA oder
DerivedC.

Dann bestimme ich per RTTI den Typ, der kann aber scheinbar nie korrekt
bestimmt werden und die Instanz wird immer als "Base" behandelt.

Das Programm habe ich unten angehängt. Übersetzt habe ich das Ganze ohne
weitere Kommandozeilenoptionen.

Danke für Tipps,
Torsten.

#include
#include

using namespace std;

class Base {
public:
Base() {
cout << "c'tor Base" << endl;
}

Hi,
ich habe mal einen Blick auf den RFC 1321 geworfen und bin dabei auf
diese Codestelle gestoßen:
void MD5Init (context)
MD5_CTX *context;
{ ... }

Ich nenne es jetzt einfach mal "Nachträgliche Typenfestlegung der
Parameter - taucht in diesem RFC öfter auf.
1. Gibt es hierfür eine Fachbezeichnung?
2. Ist das eine Spezialität von C oder gibt es das auch in etwas
veränderter Form in C++ ? Habe sowas mal eben versucht aber mein C++ -
Compiler meckert dann was von "nicht deklarierter Bezeichnen" (durchaus
nachvollziehbar für mich).

Gibt es eine Möglichkeit, Fehler der mathematischen Funktionen abzufangen?
Ein:

try { std::exp(710.); }
catch(std::exception& e) { std::cerr << e.what(); }
catch(...) { std::cerr << "error"; }

hilft nicht, bei meinem Compiler kommt eine scheinbar festverdrahtete
Fehlermeldung (exp: OVERFLOW error). Diese kommt bei GUI-Programmen
sogar als message box, die man auch noch wegklicken muss.

Markus

Hallo zusammen!

Ich habe jetzt eine Weile nichts von mir lesen lassen - kein Wunder,
denn die Antworten auf meine letzten Postings enthielten reichlich Stoff
für alles Mögliche.
Vielen Dank an den Schreiber, der mir zur Beschäftigung mit Ruby
und/oder Eclipse unter Windows riet! Hierzu: Mit Ruby werde ich mich
sicher noch beschäftigen. Wenn ich das allerdings jetzt täte, bestünde
die Gefahr, dass ich zu sehr von C++ abschweife und dass das "wieder
nichts wird".
Eclipse ist m.W.n. eine IDE - ich habe mich jetzt erstmal für Anjuta
entschieden. Das funktioniert für mich ganz gut und es hat scheinbar
nichts mit Windows zu tun (ich mag Windows nicht so sehr ...).

Inzwischen haben sich einige Dinge angesammelt, zu denen ich gerne
andere Meinungen oder sonstwie erhellende Worte lesen würde. Einiges hat
sicherlich eher filosofischen Charakter, wahrscheinlich bin ich hier mit
der einen oder anderen Sache gar OT.

Hi,
ich möchte ein Zeichen (char -> 8 Bit) in ein bool[8]-Array
"reinpacken", sodass ich später per Index auf jedes einzelne Bit
zugreifen kann. Wie stelle ich sowas an? Oder noch besser: Gibt es eine
Möglichkeit, bitweise auf ein Zeichen zuzugreifen (d.h. ich greife auf
Bit X von char Y zu)?
Andy

Hallo,

wenn ich mir die Container-Klassen in der STL so ansehe, dann sehe ich
immer wieder gleiche Operatoren (z.B. push_back). Werden z.B. std::list
und std::vector von einer gemeinsamen Basisklasse abgeleitet?

Gibt es irgendwo eine Referenz über die Vererbungsbeziehungen innerhalb
der STL? In den Header-Dateien selbst nachschauen hat sich als recht
mühsam erwiesen.

Gruß
Andreas