i know that normal member functions are instantiated when called, not when the class itself is instantiated

What do you mean by "normal member functions"? 1) non-template non-static member functions of template classes 2) template non-static member functions of template classes 3) template non-static member functions of non-template class ?

when are static member functions of class templates instantiated? when the class itself is instantiated? or when the function is called?

and i'm trying to figure out about non-template static member functions of template classes

The actual code for that kind of member function generated when class itself is instantiated

nope. std::vector<int> vec; won't generate code for std::vector<int>::begin(); it will only be generated when needed

nope. std::vector<int> vec; won't generate code for std::vector<int>::begin(); it will only be generated when needed

Lippman's book

Provide the quote please

Is there any good compiler for c++ windows 7

did

I'll ask about it in Russian C++ chat

Windows 7 is EOL, switch to Linux

switch to Win10 *

switch to Win10 *

Switch to Linux

How I could do that?? Sorry for bothering

by default, a member function of a class template is instantiated only if the program uses that member function. For example, this code // instantiates Blob<int> and the initializer_list<int> constructor Blob<int> squares = {0,1,2,3,4,5,6,7,8,9}; // instantiates Blob<int>::size() const for (size_t i = 0; i != squares.size(); ++i) squares[i] = i*i; // instantiates Blob<int>::operator[](size_t) instantiates the Blob<int> class and three of its member functions: operator[], size, and the initializer_list<int> constructor. If a member function isn’t used, it is not instantiated. The fact that members are instantiated only if we use them lets us instantiate a class with a type that may not meet the requirements for some of the template’s operations (§ 9.2, p. 329). By default, a member of an instantiated class template is instantiated only if the member is used.

by default, a member function of a class template is instantiated only if the program uses that member function. For example, this code // instantiates Blob<int> and the initializer_list<int> constructor Blob<int> squares = {0,1,2,3,4,5,6,7,8,9}; // instantiates Blob<int>::size() const for (size_t i = 0; i != squares.size(); ++i) squares[i] = i*i; // instantiates Blob<int>::operator[](size_t) instantiates the Blob<int> class and three of its member functions: operator[], size, and the initializer_list<int> constructor. If a member function isn’t used, it is not instantiated. The fact that members are instantiated only if we use them lets us instantiate a class with a type that may not meet the requirements for some of the template’s operations (§ 9.2, p. 329). By default, a member of an instantiated class template is instantiated only if the member is used.

by default, a member function of a class template is instantiated only if the program uses that member function. For example, this code // instantiates Blob<int> and the initializer_list<int> constructor Blob<int> squares = {0,1,2,3,4,5,6,7,8,9}; // instantiates Blob<int>::size() const for (size_t i = 0; i != squares.size(); ++i) squares[i] = i*i; // instantiates Blob<int>::operator[](size_t) instantiates the Blob<int> class and three of its member functions: operator[], size, and the initializer_list<int> constructor. If a member function isn’t used, it is not instantiated. The fact that members are instantiated only if we use them lets us instantiate a class with a type that may not meet the requirements for some of the template’s operations (§ 9.2, p. 329). By default, a member of an instantiated class template is instantiated only if the member is used.

https://kubuntu.org https://spins.fedoraproject.org/kde/

The reason to this kind of behavior is providing ability for example to instantiate a vector of non-copyable and non-movable type. You can use this vector but the resize member will not be instantiated.

Because lol has no operator<

So instantiation of temp<lol> doesn't lead to compiler error

lemme rephrase what i understand you are saying and what i am saying you are saying that the code for temp<lol>::fn() was generated when i did temp<lol> test2; only there was a blank for the location of operator< in the code. the compiler tried to fill the blank only when i did fn(test2, test2) and that is why i got the error when doing this but not when i left out any usage of temp<lol>::fn() i am saying that an attempt to generate the entire code for temp<lol>::fn() failed when i called fn(test2, test2); and not before that. this is why i did get the error when doing this but not when i left out usages of temp<lol>::fn();

No. You said temp<lol>::fun was never generated to begin with. I said it was and that the compiler deferred the error to a later point of time. This could result in either a compiler error or a linker error at a later point of time.

"but not of the definitions or default arguments, of the class member functions, member classes, static data members and member templates;" my question was if "class member functions" included static member functions

no i think i was right. static member functions are a subset of member functions 11.4.8.1 Static member functions [class.static.mfct] 1 [Note: The rules described in 11.4.1 apply to static member functions. — end note] the rules in 11.4.1 are about class member functions the rules special to non-static member functions are in 11.4.2