what is virtual function?
117456
a function that is designed to be overwritten. virtual functions may change their implementations in sub-classes.
594479
Non-virtual member functions are resolved statically. That is, the member function is selected statically (at compile-time) based on the type of the pointer (or reference) to the object. \n\nIn contrast, virtual member functions are resolved dynamically (at run-time). That is, the member function is selected dynamically (at run-time) based on the type of the object, not the type of the pointer/reference to that object. This is called "dynamic binding." Most compilers use some variant of the following technique: if the object has one or more virtual functions, the compiler puts a hidden pointer in the object called a "virtual-pointer" or "v-pointer." This v-pointer points to a global table called the "virtual-table" or "v-table." \n\nThe compiler creates a v-table for each class that has at least one virtual function. For example, if class Circle has virtual functions for draw() and move() and resize(), there would be exactly one v-table associated with class Circle, even if there were a gazillion Circle objects, and the v-pointer of each of those Circle objects would point to the Circle v-table. The v-table itself has pointers to each of the virtual functions in the class. For example, the Circle v-table would have three pointers: a pointer to Circle::draw(), a pointer to Circle::move(), and a pointer to Circle::resize(). \n\nDuring a dispatch of a virtual function, the run-time system follows the object's v-pointer to the class's v-table, then follows the appropriate slot in the v-table to the method code. \n\nThe space-cost overhead of the above technique is nominal: an extra pointer per object (but only for objects that will need to do dynamic binding), plus an extra pointer per method (but only for virtual methods). The time-cost overhead is also fairly nominal: compared to a normal function call, a virtual function call requires two extra fetches (one to get the value of the v-pointer, a second to get the address of the method). None of this runtime activity happens with non-virtual functions, since the compiler resolves non-virtual functions exclusively at compile-time based on the type of the pointer.
801215
Remote Procedure Call is a protocol allowing a process running on one computer to execute a subroutine on another. \n\nIt involves networking.
734485
The signature of a function include it's return type, it's arguments types, it's modifiers, and it's name.  \n\nIt must be unique in a given scope and is the way it is identified by the compiler.  The way it write itself as a unique entity, so by analogy it's called a signature.
909871
Virtual memory is used when the computer runs out of physical memory (RAM). You should never decrease this below a certain level. However, setting this above the recommended setting is wasteful. On an average computer, a 1gb swap file (what is used for virtual memory) is considered to be the norm. Ideally, however, your operating system will adjust the swap file for you and you don't have to worry about it (as Windows does). Basically having too little is very very bad.
1056506
A widget (or control) is an interface component that a computer user interacts with, such as a window or a text box. Widgets are sometimes qualified as virtual to distinguish them from their physical counterparts, e.g. virtual buttons that can be clicked with a mouse cursor, vs. physical buttons that can be pressed with a finger. Widgets are often packaged together in widget toolkits. Programmers use widgets to build graphical user interfaces (GUIs).\n\nOne commonly referred to type of widgets are the Dashboard widgets of Apple Macintosh computer users. Widgets, in this case, are downloadable interactive virtual tools that provide services such as showing the user the latest news, the current weather, a dictionary, a map program, sticky notes, or even a language translator, among other things.
120442
Because of the way you would call the function \nsomefunct(param1, param2, param3); // canonical\nsomefunct(param1, param2); // compiler knows you mean to use the default param for 3 because it´s the third param you don´t provide.
561330
In physics, a virtual particle is a particle-like abstraction used in some models of quantum field theory. Virtual particles exhibit some of the phenomena that real particles do such as conservation of charge. Nevertheless they are unobservable by their very definition, and furthermore do not respect some of the most fundamental laws associated with physical particles. The concept of virtual particles necessarily arises in the perturbation theory of quantum field theory where interactions between real particles are described in terms of exchanges of virtual particles. Any process involving virtual particles admits a schematic representation known as a Feynman diagram which facilitates understanding of calculations.\n\nThe term is rather loose and vaguely defined, in the sense that it clings to a rather incorrect view that the world is somehow made up of "real particles": it is not; rather, "real particles" are more accurately understood to be excitations of the underlying quantum fields. As such, virtual particles are also excitations of the underlying fields, but are "temporary" in the sense that they appear in calculations, but never as indexes to the scattering matrix. In this sense, virtual particles are an artifact of perturbation theory, and do not appear in a nonperturbative treatment. As such, their existence is questionable; however, the term is useful in informal, casual conversation, or in rendering concepts into layman's terms.\n\nThere are two principal ways in which the notion of virtual particles appear in modern physics. They appear as intermediate terms in Feynman diagrams; that is, as terms in a perturbative calculation. They also appear as an infinite set of states to be summed or integrated over in the calculation of a semi-non-perturbative effect. In the later case, it is sometimes said that virtual particles cause the effect, or that the effect occurs because of the existence of virtual particles.\n\nIn the latter class, there are six well-known effects in particle physics that are often ascribed to virtual particles (specifically to virtual photons in all but the last case):\n\nThe spontaneous emission of a photon during the decay of an excited atom or nucleus; such a decay is prohibited by ordinary quantum mechanics and requires the quantization of the electromagnetic field for its explanation, \nThe Casimir effect, where the the ground state of the quantized electromagnetic field causes a weak, short-range attraction between a pair of electically neutral metal plates, \nThe van der Waals force, which is essentially the Casimir effect between two atoms, \nVacuum polarization, which involves pair production or the decay of the vacuum, which is the spontaneous production of particle-antiparticle pairs (such as electron-positron), \nHawking radiation, where the gravitational field is so strong that it causes the spontaneous production of particle pairs. \nMost of these have analogous effects in solid-state physics; indeed, one can often gain a better intuitive understanding by examining these cases. In semiconductors, the roles of electrons, positrons and photons in field theory are replaced by electrons in the conduction band, holes in the valence band, and phonons or vibrations of the crystal lattice.\n\nAntiparticles have been proven to exist and should not be confused with virtual particles or virtual antiparticles.
344305
Yes Virtual methods in C++ can have implementations.
60572
The typical rule is that if your class has at least one virtual function, you should always declare your class destructor as virtual.\n\nClasses with virtual functions are usually designed to be used as base classes for other classes and because you can assign a pointer to a derived class to a base class pointer, a virtual destructor is needed to make sure that the derived classes destructor is called.\n\nSee the section (and code example) entitled "Why are destructors not virtual by default?" in Bjarne Stroustrup's (creator of the C++ language) C++ FAQ at the link below.
5482
Encapsulation is often confused with information hiding. However, these terms are not interchangeable. Encapsulation is the ability to bundle related data and functionality within a single, autonomous entity called a class. For example, a class called LoggerFile might bundle data members such as the log file's path; a buffer of data waiting to be written to that file; and member functions that open, read, write, and close that file, as in the following code listing:\n\nclass LogFile\n{\npublic:\n int Open();\n int Read(char *buff);\n int Write(const char *buff);\n int Close();\nprivate:\n FILE *logfile;\n bool _open;\n//...additional data members\n};In procedural languages such as C, you declare these data members and the associated functions separately. Consequently, a global function that opens a log file may be mistakenly called to open a file that has already been opened. Worse yet, users might delete a log file and then attempt to write to it. By bundling the data and functionality in an autonomous class, it's much easier to avert such human errors, because the class maintains the state of the file and is therefore able to prevent such errors.\n\nAbstract classes can be used to define the C++ version of interfaces. A C++ abstract class describes functionality shared by objects of all concrete classes that are explicitly listed (perhaps indirectly) as subclasses. An object may play multiple roles by inheriting and implementing multiple interfaces. (The language doesn't directly support notions that an object may play different roles at different times, or that a role is implemented by a collection of objects, but these effects can usually be had in one way or another.) \n\nC++ interface-style abstract classes take an idiomatic form: \n\nclass AnInterface {\npublic:\n  virtual T1   aService(T2, T3) = 0;\n  ...\n  virtual T4   anAttribute() const = 0; // get value\n  virtual void anAttribute(T4) = 0;     // set value\n  ...\n  virtual T5   aReadOnlyAttribute() const = 0;\n\n  virtual ~AnInterface() {}\n\nprotected:\n  AnInterface() {}\n};\n\nIdeally, the types T should consist only of pass-by-value scalar types (int, float, enum, ...), collections of them (structs, ...) and/or pointers to objects of classes also defined via abstract classes (thus representing handles). The lack of native by-value string and array types in C++ is a problem here. One occasionally attractive alternative is to always contain fixed arrays in structs. But in practice, you can make ADT-style types work OK too. This way you can sometimes obtain simpler mechanics and also avoid value copying. ADT-style fake pointer classes may also be used instead of raw pointers for handle types, although there is no perfect way to do this. \n\nAbstract classes sometimes lend themselves to parameterization over some type used in one or more signatures. (Some nice examples are described in Barton and Nachman's book.) Beyond the template prefix, nothing much changes except for the pragmatic problems of dealing with templates in C++. These include for example the fact that template instantiation errors are not usually reported until link time. This is best combatted by prefacing each template with a brief comment about what operations are assumed to be supported on the type (e.g., a < comparison). \n\nSince interface classes cannot be directly instantiated, yet serve as virtual base classes for implementations, the constructors should take no arguments and should be listed as protected. Also, for similar reasons, abstract classes should have a no-op virtual destructor, not one listed as ... = 0. Depending on your compiler, you might need to define the no-op constructor and destructor operations outside the class declaration in a separate .C file. \n\nThe use of const here and elsewhere has its ups and downs. Officially, it is a good idea, since it helps enforce some of the intended semantic guarantees. But often enough, pragmatic concerns get in the
887573
what do you mean by parent function, can you clarify???????
296652
Where's the function?
241658
YES !!!\nA variable y is a function of x if a relation between x and y produces exactly one value of y for each value of x.\n\nThis is not a higher education question !
173935
Are you referring to Virtual Storage (Also called Virtual Memory)?\n\nVirtual memory or virtual memory addressing is a memory management technique, used by multitasking computer operating systems wherein non-contiguous memory is presented to a software application as contiguous memory. The contiguous memory is referred to as the virtual address space.  The vitual address space is typically 4-10 times the size of the actual physical memory.\n\nThe term "virtual memory" often involves the use of "memory swapping" (or "page/swap file" use).\n\nIn technical terms, virtual memory allows software to run in a memory address space whose size and addressing are not necessarily tied to the computer's physical memory.
763483
If u're asking about boolean "v", then it represents the "OR" function. (And the "reversed v" i.e. "^" represents the "AND" function);\n\n0 v 0 = 0\n0 v 1 = 1\n1 v 0 = 1\n1 v 1 = 1
105117
Basically, you have one structure with some functions definitions and/or variables.  Then you make another structure that inherits the functions and varaibles from the 1st structure.  This new struture can have new variables and functions as well.  Some of this is language dependent.