Thread: Partial Specialization error?

This error has me completely stumped. I've never heard of it (or had it) before.

I've got a Write function in my Dataf class, which needs to be able to write all manner of data to the specified file, so I declared it a template function:

Code:

template <typename T> void Dataf::Write<T> (std::string fileName, T data)
{
		std::ostream	fd (fileName.c_str());
		std::string	 errorBuf ("Error opening data file [");

		if (!fd.is_open()) {
			 errorBuf += fileName + "], make sure you have write permissions.\n";
				KillGame (errorBuf);
		}

		fd >> data;
}

Only the Write function is a template, not the entire class. For reference:

Code:

class Dataf
{
		public:
				Dataf ();
				~Dataf ();

			    std::string Read (std::string fileName);
			 template <typename T> void Write<T> (std::string fileName, T data);
		private:

};

Here's the exact error output:

include/dataf.h:20: error: partial specialization `Write<T>' of function
template
dataf.cpp:45: error: partial specialization `Write<T>' of function template

I took a look at this error and just said 'what?'.

*edit*

Ewww, I just looked at the layout. Not pretty, but I blame VIM

Is there any reason you're qualifying Write with <T>? Remove the red part for both your declaration and definition:

Code:

template <typename T> void Write<T> (std::string fileName, T data);

Yes it wasn't there to start off with, but I get an 'undeclared function'-esque error. Write is qualified with <T> because I call it like so:

Code:

dfile->Write<std::string> (fileName, "Lee");

*edit*

Salem where are yoooooooooooo?

Salem where are yoooooooooooo?

Why are you calling for someone else? I solved your problem, but your compiler isn't smart enough to handle templates correctly. There's nothing wrong with how you call the function. So you're gonna have to find a workaround to handle ambiguous types:

Code:

#include <iostream>
#include <string>

using namespace std;

class Dataf
{
public:
  template <typename T> void Write (string fileName, T data);
};

template <typename T> void Dataf::Write (string fileName, T data)
{
  cout << sizeof data << '\n';
}

template <> void Dataf::Write<string> (string fileName, string data)
{
  cout << sizeof data << '\n';
}

int main()
{
  Dataf d;

  d.Write<string>("test", "test");
  d.Write("test", "test");
}

Hmm I think GCC is more than capable.

Hmm I think GCC is more than capable.

Hmm, apparently not. Have you tried your code on multiple compilers? I have. Including Comeau. I don't think anyone will argue that Comeau is the most conforming compiler when it comes to templates.

By the way, sorry about snapping at you about the Salem thing. It's just really insulting to help someone and then see them immediately ask for help from someone else.

Hi,

Try the following code:

I removed the <T> as that should not be there, and made some fixes to your Write function.

By the way, this does compile with gcc.

Code:

#include <string>
#include <fstream>

class Dataf
{
public:
        Dataf();
        ~Dataf();

        std::string Read (std::string fileName);

        // Removed <T> as that is used in partial specialization
        // And this is not what is being done here.
        template <typename T> void Write(std::string fileName, T data);
};

Dataf::Dataf()
{
}

Dataf::~Dataf()
{
}


// removed the <T> as that syntax is used in partial specialization
// and that is not what is being done here.
template <typename T> void Dataf::Write (std::string fileName, T data)
{
                //Changed ostream to ofstream - ofstream is an output file stream
                std::ofstream   fd (fileName.c_str());
                std::string      errorBuf ("Error opening data file [");

                if (!fd.is_open()) {
                         errorBuf += fileName + "], make sure you have write per
missions.\n";
                //              KillGame (errorBuf);
                }

                // Changed >> to << as << is used for writing to a file
                fd << data;
}

int main()
{
   Dataf *dfile = new Dataf();
   std::string fileName("fname.out");
   dfile->Write<std::string> (fileName, "Lee");
   delete dfile;
}

Jeebus. whats all this about partial specialisations of template functions. They dont exist. Only template classes can be partially specialised. You may fully specialise a function template but not partially.

Originally Posted by Narf

Hmm, apparently not. Have you tried your code on multiple compilers? I have. Including Comeau. I don't think anyone will argue that Comeau is the most conforming compiler when it comes to templates.

By the way, sorry about snapping at you about the Salem thing. It's just really insulting to help someone and then see them immediately ask for help from someone else.

Thats ok
Thanks to both of you.