Thread: How do I create a filename with multiple variable types

sscanf() ought to work:

Code:

#include <cstdio>

char *filenameExample = "01-31-12";
int month, day, year;

std::sscanf(filenameExample, "%d-%d-%d", &month, &day, &year);

(For those about to complain that I used a C function, have your C++ version ready for comparison)

Originally Posted by brewbuck

(For those about to complain that I used a C function, have your C++ version ready for comparison)

Not too difficult:

Code:

int month, day, year;
std::stringstream ss("01-31-12");
ss >> month >> literal('-') >> day >> literal('-') >> year;
// or:
ss >> month >> '-' >> day >> '-' >> year;

if only we had continued working on getting an input matching manipulator standardised, or getting the formatted read to ignore literals added to the standard I/O streams

[hangs head in shame]

We were working on a project to allow one or the other to work as part of the C++ standard library, but brewbuck decided that he did not have the time to see it through.

Originally Posted by manasij7479

How can the second one be implemented ?

By overloading operator>> in the std namespace (for argument dependent lookup) to have two parameters: a non-const reference to std::basic_istream and a const reference to char.

Originally Posted by manasij7479

(The first one, I think, can just be a templated function, taking and returning a reference to the istream involved, plucking out the argument passed into it. Am I right ?)

No, it is not as simple as that because the function call does not involve the istream. One way out is for the function call to create an object that has operator>> overloaded for basic_istream. This object then contains the argument provided as an argument to the input manipulator, and then its operator>> uses that value to perform the input manipulation.

Originally Posted by laserlight

No, it is not as simple as that because the function call does not involve the istream. One way out is for the function call to create an object that has operator>> overloaded for basic_istream. This object then contains the argument provided as an argument to the input manipulator, and then its operator>> uses that value to perform the input manipulation.

After simplifying a little and abstracting the work of the >> in the () operator, here is my try:

Code:

template<typename T>
class literal
{
    T t;
public:
    literal(T t_):t(t_){};
    istream& operator()(istream& is)
    {
        T temp;
        is>>temp;
        if(temp!=t)is.setstate(ios_base::failbit);
        return is;
    }
};
template<typename T>
istream& operator>>(istream& is,literal<T> lt)
{
    return lt(is);
}

Example use:

Code:

int main()
{
    int x,y;
    cin>>x>>literal<char>('+')>>y;
    cout<<x<<endl<<y;
    return 0;
}

Doe this fall short anywhere ?

Originally Posted by laserlight

By overloading operator>> in the std namespace (for argument dependent lookup) to have two parameters: a non-const reference to std::basic_istream and a const reference to char.

Hrm. That causes an ambiguous overload for me: the compiler cannot decide between std::stringstream::operator >> (int&) and std::operator > (std::stringstream&, const char&).

Just for the sake of it, I made an attempt at implementing the first method:

Code:

#include <sstream>
#include <iostream>
#include <assert.h>

template<typename StreamT>
class XLiteral
{
public:
	XLiteral(char c): m_c(c) {}
	void SetStream(std::basic_istream<StreamT>& stream) { m_stream = &stream; }
	template<typename T> XLiteral& operator >> (T& rhs) { assert(m_stream); *m_stream >> rhs; return *this; }
	char GetChar() const { return m_c; }

protected:
	std::basic_istream<StreamT>* m_stream;
	char m_c;
};

template<typename StreamT>
XLiteral<StreamT> & operator >> (std::basic_istream<StreamT>& lhs, XLiteral<StreamT>& rhs) 
{
	char tmp;
	lhs >> tmp;
	assert(tmp == rhs.GetChar());
	rhs.SetStream(lhs);
	return rhs;
}

template<typename StreamT>
XLiteral<StreamT> literal(StreamT c) { return XLiteral<StreamT>(c); }

int main()
{
	int month, day, year;
	std::stringstream ss("31-01-12");
	ss >> day >> literal('-') >> month >> literal('-') >> year;
}

(Also took the liberty to fix the date format.)

It compiles and works fine under Visual Studio, but not with Comeau. Dunno why. I am probably missing something trivial.

It complains there is no match for operator >> (basic_istream<T>, XLiteral). But the WHY is what I don't understand.
basic_istream is a template class and istream is a typedef for basic_istream<char>. This way, you can use either char or wchar_t.