|
The documentation[^] explains what the function does, and suggests that it should be called immediately after a Window is created. This has always been my understanding, and the remainder of the time you just use InvalidateRect or InvalidateRgn to queue the redrawing messages.
Veni, vidi, abiit domum
|
|
|
|
|
First, the problem: I have a template class (Foo) that will have a friend operator + that takes type T as the first parameter, and type Foo<T> as the second. The forward declaration is:
template<class T> struct Foo;
template<class T> Foo<T> operator +(T const a1, Foo<T> const &a2);
I am using Visual Studio 2010 Pro. Doing a search resulted in the following two links that I thought would be helpful:
http://www.parashift.com/c++-faq-lite/template-friends.html[^]
http://publib.boulder.ibm.com/infocenter/lnxpcomp/v7v91/index.jsp?topic=/com.ibm.vacpp7l.doc/language/ref/clrc16friends_and_templates.htm[^]
These recommendations lead me to try the following after the above forward declaration:
template<class T = double>
struct Foo {
private:
T m_Data;
friend Foo<T> operator +(T const a1, Foo<T> const &a2);
friend Foo<T> operator + <>(T const a1, Foo<T> const &a2);
friend Foo<T> operator + <T>(T const a1, Foo<T> const &a2);
template<>
friend Foo<T> operator +(T const a1, Foo<T> const &a2);
public:
Foo operator +(T const addend);
};
template<class T>
Foo<T> operator +(T const a1, Foo<T> const &a2) {
return (a2 + a1);
}
Is there some way to accomplish this? It works if I define (implement) the method within the class declaration, but I prefer to define the method body with the other method declarations (in an included cpp file) for consitency and cleanliness. Thanks,
Sounds like somebody's got a case of the Mondays
-Jeff
|
|
|
|
|
I think you need to explicitely add an inline to the declaration as well as the definition. We had a similar problem with a derived template class and solved it that way.
The good thing about pessimism is, that you are always either right or pleasently surprised.
|
|
|
|
|
Unfortunately, marking the declarations inline had no noticeable effect. Thanks for the suggestion, though.
Sounds like somebody's got a case of the Mondays
-Jeff
|
|
|
|
|
Here's something that worked for me:
template <class BaseType>
class iReadContainer
{
template <class> friend bool operator== (const iReadContainer<BaseType>& one, const iReadContainer<BaseType>& other);
};
P.S.: In previous versions of VS this didnt work either. back then I used to declare a friend helper class in such cases, e. g. :
template <class T>
class vec3 {
T val[3];
public:
...
friend class vec3_operator_helper; };
class vec3_operator_helper {
public:
template <class T> static
vec3<T> add (const vec3<T>& v1, const vec3<T>& v2); };
template <class T>
vec3<T> operator+(const vec3<T>& v1, const vec3<T>& v2);
template <class T>
vec3<T> operator+(const vec3<T>& v1, const vec3<T>& v2) {
return vec3_operator_helper::add(v1, v2);
}
GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)
modified 28-Nov-13 5:49am.
|
|
|
|
|
Unfortunately, your first recommendation didn't work for me. However, I was also getting intellisense errors when building with the method definition within the declaration. Adding
template<class> prior to the definition prevented those errors from appearing. Note that intellisense errors do not prevent code from successfully compiling.
I am sure your second recomendation would work, but it is a bit verbose for what I am attempting to accomplish, so I decided to move the definitions into the header file. Thanks,
Sounds like somebody's got a case of the Mondays
-Jeff
|
|
|
|
|
Hmm, that's odd, I also use VS 2010. I don't use Intellisense though, since I've installed VisualAssist X which works a lot better and is less intrusive.
I agree that my second suggestion is rather awkward, but I used it anyway because there were a lot of operators to declare in that particular case! It's probably not worth it if you only have two or three ...
GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)
|
|
|
|
|
WIN32_FIND_DATAA data;
HANDLE h = FindFirstFile(".\\images\\*?*",&data);
This is returning a INVALID_HANDLE_VALUE handler. in Window XP while in Windows 7 it is working fine.
In XP if you will run this use case it will work.
but after doing another some use case and then will run it it will give exception.
|
|
|
|
|
In case of errors call GetLastError() to know about the reason of the failure. To get the corresponding error message use FormatMessage(). When not using FormatMessage() you can lookup the error number in WinError.h to get the english error message.
Don't forget to close the returned handle using FindClose() when a search operation has been finished.
|
|
|
|
|
|
"*?*" is the same as "*" under Win-XP at least. Did you hope for something else?
Gisle V.
# rm -vf /bin/laden
/bin/rm: success
|
|
|
|
|
Check what the current directory is.
|
|
|
|
|
sachanratnesh wrote:
HANDLE h = FindFirstFile(".\\images\\*?*",&data);
Are you confusing relative vs. absolute paths? Since you are using the former, does the "images" folder exist in the same folder as the exe that is running?
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
|
|
|
|
|
Hello,
What I am looking for:
A Front end basically . I would like a C++ API for plotting numerical results in browser window or an API for plotting numerical results and creating the GUI.
I currently have 3 applications talking to one another:
1. Embedded code backend writen in C/C++, talks to microcontroller over a USB-Serial Port, downsamples, labels and sends the data to the front end over TCP Sockets.
2. Numerical Simulator written in C++, sending calculations to front end over a JNI Interface.
3. Java front end writing to a database, displaying received data as graphs using plot utilities.
I would very much like to do away with the Java front end and use a simple utility for plotting. My criteria for the plotting in order of importance:
1. Plot both Time scale data and flash relevant values like you would see on a ICU screen.
2. Plot at least every 100ms, data is generated every 1 - 10 ms.
3. Easy to understand and implement. I am not much of a GUI/graphics programmer, my time is mostly spent on numerical simulations .
4. Nice if I could move to browser based plotting, easier portability in our lab environment.
I use minGW and work in cygwin/windows.
Thanks and Regards,
kpks
modified 28-Nov-13 1:04am.
|
|
|
|
|
And? What is your question/request?
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
To put it very very succinctly, I am looking for an API in C++ to replace the GUI Developed in ECLIPSE and the plotting accomplished with Chart2D / LiveGraph in JAVA
|
|
|
|
|
Is the result of the sizeof operator determined by the compiler or filled in by the linker?
Consider the following:
My C++ project links with a commercial static library. The provider of the static library has supplied header files for the classes contained therein.
These header files describe the public interfaces of the classes, but do not reveal the private members.
Therefore, how does the build system know the size of a certain class if all I have is a header file with only the public interface?
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
You cannot use incomplete types with the sizeof operator.
«_Superman_»
I love work. It gives me something to do between weekends.
Microsoft MVP (Visual C++) (October 2009 - September 2013) Polymorphism in C
|
|
|
|
|
Thank you.
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
Richard Andrew x64 wrote: These header files describe the public interfaces of the classes, but do not
reveal the private members.
The class must be declared in the header file else you would have a load of 'undefined type' errors and the class must have its provate members too.
|
|
|
|
|
Thank you.
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
If there are no private members in these headers then there are none! In C++ you cannot hide the members of a class. However, the class supplied in the header may just be an interface, and the actual implementation may come from a derived class which you don't know (and don't need to know) the definition of! If the class in question has no public constructor, this is a sign that it is in fact an interface. Instead it may provide some sort of "create" function.
Here as an example for the public interface of such a library:
class ILog {
public:
static ILog* createInstance(const std::string& name); virtual ~ILog() {}
virtual void Info(const std::string& context, const std::string& message)=0;
virtual void Warning(const std::string& context, const std::string& message)=0;
virtual void Error(const std::string& context, const std::string& message)=0;
};
And hidden in your library, this may be the implementation class:
class CLog : public ILog {
std::string name_;
public:
CLog(std::string& name) : name_(name) {} virtual ~CLog() {}
virtual void Info(const std::string& context, const std::string& message);
virtual void Warning(const std::string& context, const std::string& message);
virtual void Error(const std::string& context, const std::string& message);
};
ILog* ILog::createInstance(const std::string& name) {
return new CLog(name);
}
GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)
|
|
|
|
|
Stefan_Lang wrote: However, the class supplied in the header may just be an interface, and the actual implementation may come from a derived class which you don't know
OH, I see. That's quite clever.
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
Stefan_Lang wrote: and the actual implementation may come from a derived class which you don't know
(and don't need to know) the definition of
But wil still have to be declared in a header file included in the file the derived class' is declared in otherwise it still wont compile.
|
|
|
|
|
Only the distributor of the library will need to compile the derived class, not the person using the API!
GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
