ich habe ein Linkerproblem bei oben genannter Situation.
Eine ganz normale nicht-template-Klasse benötigt eine Funktionalität, die am besten mit einer templatefunktion zu realisieren ist. Diese funktion braucht aber zugriff auf private Daten. Daher muss sie befreundet sein. Der Code sieht so aus:

h-Datei:

class A : public B
{
    Q_OBJECT

public:
// Konstruktor, Funktionen usw...
protected:
// Daten, die meine befreundete Funktion nutzen können muss

    QHostAddress m_read_hostaddress;
    QUdpSocket* m_read_socketdevice;
private:
// Daten die meine befreundete Funktion nutzen können muss
    QByteArray m_sendbuffer;
    QDataStream m_ds;
// Jetzt kommen die nötigen befreundeten Funktionsdefinitionen
    friend bool sendValue(A, int, double);
    friend bool sendValue(A, int, float);
    friend bool sendValue(A, int, int);
    friend bool sendValue(A, int, bool);
};

// Jetzt kommt die befreundete Funktion als template:
template <typename T>
bool sendValue(A a, int id, T value)
{
// Hier passiert dann was
}

cpp-Datei

bool A::tu_was(double heading)
{
    return  sendValue(APHDG, heading);
}

Also so funktioniert es nicht.
Dann hab ich versucht, statt send Value(A a,...) sendValue(const A* a,...) zu machen und bei den funktionsaufrufen immer (this, ...) zu machen.

Das kompiliert und linkt zwar als statische lib, aber wenn ich mein Hauptprogramm das diese staticlib nutzt, linke, bekomme ich undefined references auf eben diese Funktion sendValue().

Nu bin ich am Ende mit meinem Latein und hoffe auf guten Input!
Danke!

class A : public B
{
    // ...
    template<class T> friend bool sendValue(A, int, T);
}

Hab allerdings im moment keinen compiler zur verfügung, ist also ungetestet

Diese funktion braucht aber zugriff auf private Daten.

Dann mach aus ihr doch ne Memberfunktion..

mfg
Double *T

Diese funktion braucht aber zugriff auf private Daten.

Dann mach aus ihr doch ne Memberfunktion..

Ich will aber keine template-Klasse, sondern nur eine template-funktion.

Ich will aber keine template-Klasse, sondern nur eine template-funktion.

Ein Methodentemplate macht die Klasse noch lange nicht zu einer Templateklasse.

class A
{
    public:
        template<typename U>
        bool sendValue(A a, int id, U value)
        {
            // ...
        }
};

Wo ist die Klasse nun bitte eine Templateklasse?

Ein Methodentemplate macht die Klasse noch lange nicht zu einer Templateklasse.
...
Wo ist die Klasse nun bitte eine Templateklasse?

Wenn schon, dann wird es kein Klassentemplate.

#include <iostream>

class A {
  public:
    template <typename T> friend bool SendValue(A&, int, T);
    void DoSth() {
      int x = 4;
      SendValue(*this, x, 1.0f);
    }
    bool Hello() {
      std::cout << "hello";
      return true;
    }

};

template <typename T> bool SendValue(A& a, int i, T t) {
  return a.Hello();
} 

A myobject;

int main() {
  A.DoSth();
}

compiliert eigentlich problemlos (sollte es zumindest^^), vergleich mal mit deinem Code, was da anders läuft.