0
What else can I help you with?
What is the difference between an inline object and a floating object?
A floating object can be moved independently of the surrounding text characters.
What is difference between volatile int and const volatile int?
volatile int means the code and fom outside from code can changes the value but in const volatile int, code cannot changes the value but fron ouside can change the value
C plus plus code to calculate a right angle?
Right angles are always 90 degrees. There is no need to calculate this; an angle is either 90 degrees or it is not. The following inline function is all you really need: inline const bool IsRightAngle(double angle) { return(angle==90.0); }
What is the source code for a method called max?
That depends on the programming language and the exact implementation of max. Normally, a max function returns the largest of two variables of the same type but can also be applied to a sequence container with 2 or more elements. Both versions may also include a user-defined predicate to perform the comparison(s). In the C++ standard library, it is implemented as a generic algorithm (a function template) with 4 overloads. These functions become accessible when you include the <algorithm> header from the standard library. They each have the following definitions: // TEMPLATE FUNCTION max template<class _Ty> inline _Post_equal_to_(_Left < _Right ? _Right : _Left) const _Ty& (max)(const _Ty& _Left, const _Ty& _Right) { // return larger of _Left and _Right return (_DEBUG_LT(_Left, _Right) ? _Right : _Left); } template<class _Ty> inline _Ty (max)(_XSTD initializer_list<_Ty> _Ilist) { // return leftmost/largest const _Ty *_Res = _STD max_element(_Ilist.begin(), _Ilist.end()); return (*_Res); } // TEMPLATE FUNCTION max WITH PRED template<class _Ty, class _Pr> inline const _Ty& (max)(const _Ty& _Left, const _Ty& _Right, _Pr _Pred) { // return larger of _Left and _Right using _Pred return (_DEBUG_LT_PRED(_Pred, _Left, _Right) ? _Right : _Left); } template<class _Ty, class _Pr> inline _Ty (max)(_XSTD initializer_list<_Ty> _Ilist, _Pr _Pred) { // return leftmost/largest const _Ty *_Res = _STD max_element(_Ilist.begin(), _Ilist.end(), _Pred); return (*_Res); }
Example of lazy copy in c plus plus?
Lazy copying is a hybrid of the standard shallow-copy and deep-copy mechanisms. Objects that are copy constructed or assigned from existing instances will initially be shallow-copied, meaning their dynamic data members will share the same memory. When an object is mutated whilst sharing memory, its data will be deep copied so as not to affect the shared instances. In other words, deep-copying is postponed until it is actually required (if at all). For large and complex objects, this can offer a significant memory saving and a major performance boost as a shallow copy is significantly faster than a deep copy, and sharing memory obviously consumes less memory. In order to implement lazy copying, it is necessary for each instance to be fully aware of all the instances it shares memory with. One of the simplest ways of achieving that is for each instance to maintain bi-directional pointers, similar to those you would find in a doubly-linked list. However, unlike a linked list, there is no need to expose these pointers outside of the class as the class can link and unlink all by itself, via the copy constructor and the assignment operator. All the functionality is encapsulated within the class so the lazy copy mechanism is completely transparent to the end user. The following implementation provides a brief demonstration of how the mechanism works. It is by no means a complete implementation as it can only handle one type of data, but it serves to demonstrate the key aspects of lazy copying. A more complete implementation would change the data to a template class, thus allowing any type of data to be lazy copied. The output shows that while each instance of the object occupies separate memory locations, the data they contain is initially shared. We then manipulate the objects to show that deep copying is occurring when it is required, and that destroying a share doesn't affect any remaining shares. If you strip away the trace code in the main function you will see that the lazy copy mechanism is completely transparent; you need never know it exists as it is fully encapsulated within the Object class itself. // Demonstration of a lazy copy mechanism // Copyright ©PCForrest, 2012 #include <iostream> using namespace std; // Example data container. class Data { friend ostream& operator<<(ostream& os, const Data& data); public: inline ~Data(){delete(m_num);} inline Data():m_num(new int(0)){} inline Data(const int num):m_num(new int(num)){} inline Data(const Data& data):m_num(new int(*data.m_num)){} inline Data& operator=(const Data& data){*m_num=*data.m_num; return(*this);} inline Data& operator=(const int num){*m_num=num; return(*this);} inline bool operator==(const Data& data){return(*m_num==*data.m_num);} inline bool operator!=(const Data& data){return(*m_num!=*data.m_num);} inline int operator+(const Data& data){return(*m_num+*data.m_num);} inline int operator+(const int num){return(*m_num+num);} inline Data& operator+=(const Data& data){*m_num+=*data.m_num; return(*this);} inline Data& operator+=(const int num){*m_num+=num; return(*this);} inline int GetNum()const{return(*m_num);} inline void SetNum(const int num){*m_num=num;} private: int * m_num; }; // Friend function ostream& operator<<(ostream& os, const Data& data) { os<<"Data:0x"<<&data<<" ("<<*data.m_num<<")"; return(os); } // Lazy copy class. class Object { friend ostream& operator<<(ostream& os, const Object& object); public: inline Object():m_nextshare(NULL),m_prevshare(NULL),m_data(new Data(0)){} inline Object(const Object& object):m_prevshare(&object.LocateLastShare()),m_nextshare(NULL),m_data(object.m_data){m_prevshare->m_nextshare=this;} inline ~Object(){if(IsShared())UnlinkShare();else delete( m_data ); m_data = NULL;} Object& operator=(const Object& object); Object& operator+=(const Object& object); inline Data GetData()const{return( *m_data);} void SetData(const Data& data); private: inline bool IsShared()const{return(m_prevshare!=NULL m_nextshare!=NULL);} Object& LocateLastShare()const; Object* LocateShare(const Object & object)const; void UnlinkShare(); mutable Object * m_nextshare; mutable Object * m_prevshare; Data * m_data; }; // Friend function ostream& operator<<(ostream& os, const Object& object) { os<<"Object:0x"<<&object<<"\t"<<*object.m_data; return(os); } // Assign (implements shallow-copy) Object& Object::operator=(const Object& object) { if( &object != this && // Not a self-reference. !LocateShare(object) ) // Not already shared. { // Unlink or destroy data. if( IsShared() ) UnlinkShare(); else if( m_data ) delete( m_data ); // Shallow-copy. m_data = object.m_data; // Link to new shares. m_prevshare = &object.LocateLastShare(); m_prevshare->m_nextshare = this; } return(*this); } // Add/assign (implements deep-copy) Object& Object::operator+=(const Object& object) { if( IsShared() ) { UnlinkShare(); m_data = new Data( *m_data + *object.m_data ); } else *m_data += *object.m_data; return( *this ); } // Returns a reference to the last shared instance of this instance. Object& Object::LocateLastShare()const { Object* p=(Object*)this; while(p && p->m_nextshare) p=p->m_nextshare; return(*p); } // Returns a pointer to the given object if it is amongst the shared instances // of this instance. Returns NULL if the object is this instance or is not shared. Object* Object::LocateShare(const Object& object)const { // Search previous instances first. Object* p=m_prevshare; while( p && p!=&object) p=p->m_prevshare; if(!p) { // Not found, search next instances: p = m_nextshare; while( p && p!=&object) p=p->m_nextshare; } return(p); } // Unlinks this object from its shared instances. void Object::UnlinkShare() { // Update the links on either side first. if(m_nextshare) m_nextshare->m_prevshare=m_prevshare; if(m_prevshare) m_prevshare->m_nextshare=m_nextshare; m_nextshare=NULL; m_prevshare=NULL; } // Mutator. Implements deep copy if incoming data differs. void Object::SetData(const Data& data) { if( *m_data != data ) { if( IsShared() ) { UnlinkShare(); m_data = new Data(data); } else *m_data = data; } } // Demonstration program: int main() { Object a; a.SetData( 5 ); Object b = a; // Assign (lazy copy) Object* c = new Object(b); // Copy construct (lazy copy) cout<<"Original memory:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; b += a; // Deep copy. cout<<"After mutating b:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; delete(c); cout<<"After destroying c:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<endl; // Instantiate a new, unshared instance c = new Object(); cout<<"After instantiating c as new:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; // Assign b to c *c = b; cout<<"After reassigning c:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; return(0); } Output: Original memory: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x003577B8 (5) c Object:0x00211F58 Data:0x003577B8 (5) After mutating b: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) c Object:0x00211F58 Data:0x003577B8 (5) After destroying c: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) After instantiating c as new: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) c Object:0x00211F58 Data:0x003578A8 (0) After reassigning c: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) c Object:0x00211F58 Data:0x00357818 (10)
What is the difference between v engine and inline engine?
The difference between a v engine and inline engine is that in v type engine the pistons and cylinders are aligned in in a v shape and in an inline type engine the pistons and cylinders are all vertical or inline with each other.
Difference between normal function inline function?
gffg
What is the difference between an inline graphic and a floating graphic?
inline is picture staying still and floating graphic is moving around
Difference between inline code and code behind model?
Inline code is written in html file. code behind is written in separate file.
Difference between const char and char const?
const char *p means the char value pointed by 'p' is constant we can't change anyway but the address(location) of 'p' can change. char const *p means the char value pointed by 'p' can change but the location of p can't be change it is constant.
What is the difference between an outline and inline?
For the inline functions compiler just copies the function code in that place and when the size is too big it treats that function as ordinary function.
Whats the difference between inline and ice hockey girdles?
There is no difference i have friends that play Inline Hockey and Ice Hockey and they use the same girdles. -- Inline Hockey girdles are supposed to be worn under pants, so often the surrounding nylon is not much robust, and they are tighter to the body.
Different between written and unwritten const?
The difference between written and unwritten consent is that one is actually written down on paper, and the other is an oral agreement.
What is the difference between an inline object and a floating object?
A floating object can be moved independently of the surrounding text characters.
What is the difference between an floating object and a inline object?
A floating object can be moved independently of the surrounding text characters.
What is difference between volatile int and const volatile int?
volatile int means the code and fom outside from code can changes the value but in const volatile int, code cannot changes the value but fron ouside can change the value
Write a C program to find the count of digit?
inline int getNumDigits(const int n) { return ((int) log10(n) + 1); }
