Возможно ли сделать шаблонную функцию дружественной классу?

Question

[sanek2005]

В общем, у меня есть класс. у него определенные поля. один объект этого класса является глобальной переменной. и вот так вышло, что двум шаблонным функциям надо обращаться к полям этого объекта напрямую. делать поля public не хочется, нарушается инкапсуляция. да и обращаются к ним вне класса только как раз эти два шаблона. можно ли сделать шаблонные функции членами класса - не знаю, да и они не должны ими быть по логике

Comments

[Евгений Шатунов]

sanek2005 , дружественность - это не всегда правильно и не всегда оправданно.
Тебе нужно предоставить примеры. Объявить шаблон другом - легко. Только если сделать это в лоб, то тогда дружественными будут все инстанцированные из шаблона функции. Я не думаю что тебе нужно именно это.
Поэтому сперва покажи код, на его базе можно будет дать тебе более точные рекомендации.

можно ли сделать шаблонные функции членами класса - не знаю

Знания не берутся из воздуха, знания берутся из источников знаний.
Какие причины ты видишь в том чтобы запретить определение шаблонов методов или статических функций в пространстве классов?

[sanek2005]

Евгений Шатунов, я пишу класс, который мониторит потребление памяти: записывает, для какого типа сколько выделялось памяти, подсчитывает количество выделений и общую выделенную память. есть две функции, Malloc и Free. они должны взаимодействовать с полями этого класса, чтобы подсчет работал. но при этом они не являются частью мониторинга памяти, они - просто функции для выделения и очистки памяти. да и вообще, при компиляции можно будет выбирать, будет ли этот монитор или нет. вот код, собстна

namespace memory_control
{
    class MemoryMonitor
    {
    public:
        
        unsigned int allocaledMemorySize;
        

        unsigned int AllocationCount;

        /*
        * string - type name
        * unsigned int - allocation count for this type
        */
        map<string, unsigned int> AllocatedTypes;

        MemoryMonitor()
        {
            allocaledMemorySize = 0;
            AllocationCount = 0;
        }

        bool AllMemoryIsFree()
        {
            return AllocationCount == 0;
        }

        ~MemoryMonitor()
        {
            if (!AllMemoryIsFree())
            {
                cerr << "Not all allocated memory is not free!" << endl;
            }
        }

        void MakeReport()
        {
            ofstream logFile("log.txt");
            logFile << "Memory Monitor Report" << endl;

            logFile << "----------------- Allocated types -----------------" << endl;


            for (auto type = AllocatedTypes.begin(); type != AllocatedTypes.end(); type++)
            {
                logFile << type->first << ": " << type->second << " allocations" << endl;
            }

            logFile << "Total used Memory: " << allocaledMemorySize << " bytes" << endl;

            logFile.close();
        }
    };

    MemoryMonitor memoryMonitor;

    template<typename T, typename... Args>
    T* Malloc(Args&&... args)
    {
        T* pointer = new T(args...);

        memoryMonitor.AllocationCount++;

        memoryMonitor.allocaledMemorySize += sizeof(T);

        string typeName = typeid(T).name();

        auto it = memoryMonitor.AllocatedTypes.find(typeName);

        if (it == memoryMonitor.AllocatedTypes.end())
        {
            memoryMonitor.AllocatedTypes.emplace(typeName, 1);
        }
        else
        {
            it->second++;
        }

        return pointer;
    }

    template<typename T>
    void Free(T* pointer)
    {
        delete pointer;
        pointer = nullptr;
        memoryMonitor.AllocationCount--;
    }
};

[Евгений Шатунов]

sanek2005, безотносительно качества этого кода текущий ответ является решением.

[sanek2005]

Евгений Шатунов, всмысле безотносительно? если с этим кодом есть проблемы с точки зрения качества - то скажите пожалуйста. я не против, еще новичок, будет полезно

[Евгений Шатунов]

sanek2005,

всмысле безотносительно?

Просто иногда люди не любят когда их решения комментируют без их спроса. Поэтому я написал "безотносительно".

Да, по коду есть вопросы. В коде есть проблемы.
map<string, unsigned int>
std::map работает с динамической памятью. Твой код уже на этом этапе рискует провалиться в рекурсию. Чтобы это сучилось, тебе будет достаточно перегрузить глобальный new и внутри перегрузки попробовать использовать мониторинг памяти.
Первым параметром указана строка и это не хорошо. Сравнение строк - это сравнение данных по каждому байту. Это очень медленно если мы говорим о мониторинге памяти. Логарифмическая трудоемкость std::map при доступе к элементам только усложняет весь этот процесс.
Т.к. ты пользуешься, как минимум, C++11, тебе стоит заменить std::map на std::unordered_map, которая реализует хэш-таблицу для хранения элементов.

MemoryMonitor()
{
	allocaledMemorySize = 0;
	AllocationCount = 0;
}

Ты пользуешься, как минимум, стандартом C++11, который позволяет инициализировать поля по месту определения.
Но еще до C++11 поля лучше было инициализировать через секцию инициализации конструктора.
Сегодня поля в теле конструктора инициализировать практически незачем. А определение конструктора лишь с целью инициализации полей сегодня и вовсе бессмысленно. Есть значительно более удобные механизмы.

MemoryMonitor memoryMonitor;

template<typename T, typename... Args>
T* Malloc(Args&&... args)

В этом месте есть очень большой риск обратиться к неинициализированному memoryMonitor в тот момент, когда произойдет попытка вызвать Malloc до входа в главную функцию программы.
Это называется - Static Initialization Order Fiasco.

string typeName = typeid(T).name();
std::string является еще одним потребителем динамической памяти. В этом месте ты добавляешь очень много накладных расходов на одну простую аллокацию памяти. Буквально, из одной аллокации ты делаешь, как минимум, три, а то и больше аллокаций. Этот момент катастрофически замедлит твой код.
К тому же, std::string тут тебе не нужен, т.к. typeid(T).name() возвращает статически определенную строку, адрес которой будет одинаковым.
Но и эта строка тебе, в идеале, тоже не нужна, т.к. type_info умеет возвращать хэш этой строки. Хэш будет тоже предрассчитанный. В результате тебе и map<string, unsigned int> тоже не больно нужен. Лучше ключ в карте заменить со строки на хэш. А при использовании std::unordered_map этот хэш будет использовать как есть и лишних вычислений не будет.

auto it = memoryMonitor.AllocatedTypes.find(typeName);

if (it == memoryMonitor.AllocatedTypes.end())
{
	memoryMonitor.AllocatedTypes.emplace(typeName, 1);
}
else
{
	it->second++;
}

альтернатива:
memoryMonitor.AllocatedTypes[ typeName ]++;
Давай заглянем в документацию, там пишется, что this function was specified to require mapped_type to be DefaultInsertable. Иными словами, внутри оператора при создании нового элемента для значения будет произведена явная инициализация по умолчанию, которая для тривиальных типов сводится к инициализации нулем.

И напоследок.
void MakeReport()
При наличии этой функции это точно будет монитор памяти? Она лишняя и должна быть реализована через внешнюю относительно монитора сущность. Если завтра тебе потребуется выгрузить статистику не в файл, а передать по сети, ты сюда рядом еще одну функцию напишешь? Если да, то зачем об этой новой функции знать всем пользователям монитора?
Пусть каждый тип данных у тебя решает ровно одну конкретную задачу. Хранение статистики - одна задача. Сбор этой статистики - другая задача. Выгрузка отчетов - третья задача. Пусть это все будут разные типы - разные сущности.

Answer 1

[Mercury13]

#include <iostream>

class Wrap
{
public:
    Wrap(int x) : value(x) {}
private:
    int value;

    template <class T>
    friend void out(const T&);
};

template <>
void out(const Wrap& x)
    { std::cout << x.value << std::endl; }

int main()
{
    Wrap x(42);
    out(x);
    return 0;
}

Если нужно в пространстве имён…

spoiler

#include <iostream>

namespace qq {
    template <class T>
    void out(const T&);
}

class Wrap
{
public:
    Wrap(int x) : value(x) {}
private:
    int value;

    template <class T>
    friend void qq::out(const T&);
};

template <>
void qq::out(const Wrap& x)
    { std::cout << x.value << std::endl; }

int main()
{
    Wrap x(42);
    qq::out(x);
    return 0;
}