C/C++ - Template

L'importante per adesso è avere un codice che presenta i corretti formalismi, e non sia implementato con ingenuità.
Ora provo a giocarci un po' e vedrò se la soluzione dei templare mi deluderà oppure no. Certamente avrei preferito un gestore runtime che permettesse l'inclusione della funzione una sola volta per ogni tipo, ma questo è ovviamente un limite di CPP e lo accettiamo.
Ti ringrazio Piero per l'aiuto. Buona giornata.

Ti dispiace mettere i sorgenti sia dell'header che del cpp?
Con i template ci sono un po' di problemi se si separano troppo questi due, magari stai incappando in uno di questi ma è difficile valutare senza vedere.
Basterebbero anche solo gli include e le signatures

La compilazione ora avviene come di consueto, ma se può servire..

#pragma once

#include <avr/io.h>

namespace EEPROM
{
	template <typename T> T Read(uint16_t);//(address)//Restituisce un valore di tipo {T} letto dall'EEPROM all'indirizzo {address}
	template <typename T> void Read(uint16_t, T[], uint16_t);//(address, array, n)//Legge dall'EEPROM {n} valori di tipo {T} all'indirizzo {address} e li inserisce in {array}
	
	template <typename T> void Write(uint16_t, T);//(address, value)//Scrive un valore {value} di tipo {T} nell'EEPROM all'indirizzo {address}
	template <typename T> void Write(uint16_t, T[], uint16_t);//(address, array, n)//Scrive la matrice {array} di tipo {T} di {n} elementi nell'EEPROM all'indirizzo {address} 
}

#include "EEPROM.h"

template uint8_t EEPROM::Read<uint8_t>(uint16_t);
template uint16_t EEPROM::Read<uint16_t>(uint16_t);
template uint32_t EEPROM::Read<uint32_t>(uint16_t);
template uint64_t EEPROM::Read<uint64_t>(uint16_t);
template int8_t EEPROM::Read<int8_t>(uint16_t);
template int16_t EEPROM::Read<int16_t>(uint16_t);
template int32_t EEPROM::Read<int32_t>(uint16_t);
template int64_t EEPROM::Read<int64_t>(uint16_t);
template float EEPROM::Read<float>(uint16_t);
template double EEPROM::Read<double>(uint16_t);

template void EEPROM::Read<uint8_t>(uint16_t, uint8_t[], uint16_t);
template void EEPROM::Read<uint16_t>(uint16_t, uint16_t[], uint16_t);
template void EEPROM::Read<uint32_t>(uint16_t, uint32_t[], uint16_t);
template void EEPROM::Read<uint64_t>(uint16_t, uint64_t[], uint16_t);
template void EEPROM::Read<int8_t>(uint16_t, int8_t[], uint16_t);
template void EEPROM::Read<int16_t>(uint16_t, int16_t[], uint16_t);
template void EEPROM::Read<int32_t>(uint16_t, int32_t[], uint16_t);
template void EEPROM::Read<int64_t>(uint16_t, int64_t[], uint16_t);
template void EEPROM::Read<float>(uint16_t, float[], uint16_t);
template void EEPROM::Read<double>(uint16_t, double[], uint16_t);

template void EEPROM::Write<uint8_t>(uint16_t, uint8_t);
template void EEPROM::Write<uint16_t>(uint16_t, uint16_t);
template void EEPROM::Write<uint32_t>(uint16_t, uint32_t);
template void EEPROM::Write<uint64_t>(uint16_t, uint64_t);
template void EEPROM::Write<int8_t>(uint16_t, int8_t);
template void EEPROM::Write<int16_t>(uint16_t, int16_t);
template void EEPROM::Write<int32_t>(uint16_t, int32_t);
template void EEPROM::Write<int64_t>(uint16_t, int64_t);
template void EEPROM::Write<float>(uint16_t, float);
template void EEPROM::Write<double>(uint16_t, double);

template void EEPROM::Write<uint8_t>(uint16_t, uint8_t[], uint16_t);
template void EEPROM::Write<uint16_t>(uint16_t, uint16_t[], uint16_t);
template void EEPROM::Write<uint32_t>(uint16_t, uint32_t[], uint16_t);
template void EEPROM::Write<uint64_t>(uint16_t, uint64_t[], uint16_t);
template void EEPROM::Write<int8_t>(uint16_t, int8_t[], uint16_t);
template void EEPROM::Write<int16_t>(uint16_t, int16_t[], uint16_t);
template void EEPROM::Write<int32_t>(uint16_t, int32_t[], uint16_t);
template void EEPROM::Write<int64_t>(uint16_t, int64_t[], uint16_t);
template void EEPROM::Write<float>(uint16_t, float[], uint16_t);
template void EEPROM::Write<double>(uint16_t, double[], uint16_t);

template <typename T> T EEPROM::Read(uint16_t address)
{
/**/
}
template <typename T> void EEPROM::Read(uint16_t address, T array[], uint16_t n)
{
/**/
}

template <typename T> void EEPROM::Write(uint16_t address, T value)
{
/**/
}
template <typename T> void EEPROM::Write(uint16_t address, T array[], uint16_t n)
{
/**/
}

Vedo che hai risolto... se ti interessasse saperne di più su tutti questi problemi brutti del C++: isocpp.org/wiki/faq/…

Tutti i paragrafi da lì in poi trattano questo problema, compresa la defunta keyword export e la soluzione che hai impiegato tu.

Gentilissimo.
Sai ho notato che con questo sistema forse avrebbero fatto meglio a mettere la possibilità di eliminare i template dall'header file in fase di compilazione della libreria. Tanto visto che il template viene eliminato durante la compilazione risulta inutile mantenere riferimenti ad esso, meglio averli direttamente alle funzioni compilate, cosi non dovrei specificare i tipi accettati.