implementation

Searching for symbols is a common in programming, especially when you are new to a language. For example, I had a question about the :: operator in Python, and that is not searchable. People looking for things like this or Object [] (array of Objects), would not find what they want. Why do search engines seem to ignore symbols completely? They are just characters like any others. I can see why it would be hard to extract semantics from symbols compared to words (eg: a search engine can figure out that "find," "finds," "found" are all related, if not the same word), but is it really that hard

I have an Interface and two Classes wich are implementing the Interface. public interface MyInterface { public void firstMethod(); public int secondMethod(); } public class MyClass1 implements MyInterface { public void firstMethod() {} } public class MyClass2 implements MyInterface { public void firstMethod() {} public int secondMethod() {} } The class MyClass1 is telling me to Add unimplemented methods , because the secondMethod is not implemented, OK I will do that. But the problem is that I don't need this method in MyClass1 . In your opinion what is the best thing to do? Add the

I'm currently learning Smalltalk in the Squeak environment and I'm reading "Squeak - A Quick Trip To ObjectLand". I enter the object-oriented paradigm with some prior knowledge from Python and Java and this sentence from the book on page 36 has made me think: Smalltalk is a class-based implementation of an object-oriented language. Short sentence but very interesting. In OO all terms like class, object, instance seem to be well-defined and seem to point to the one and only true meaning and you're likely to come across generic sentences like "objects are instances of a class". But you hear

This question regards the implementation of ThreadLocalRandom in OpenJDK version 1.8.0. ThreadLocalRandom provides a per-thread random number generator without the synchronization overhead imposed by Random. The most obvious implementation (IMO) would be something like this, which appears to preserve backward compatibility without much complexity: public class ThreadLocalRandom extends Random { private static final ThreadLocal<ThreadLocalRandom> tl = ThreadLocal.withInitial(ThreadLocalRandom::new); public static ThreadLocalRandom current() { return tl.get(); } // Random methods moved here

Suppose I have class A { public: void print(){cout<<"A"; }}; class B: public A { public: void print(){cout<<"B"; }}; class C: public A { }; How is inheritance implemented at the memory level? Does C copy print() code to itself or does it have a pointer to the it that points somewhere in A part of the code? How does the same thing happen when we override the previous definition, for example in B (at the memory level)? Compilers are allowed to implement this however they choose. But they generally follow CFront's old implementation. For classes/objects without inheritance Consider: #include

I have a class: C.h class C { private: template<int i> void Func(); // a lot of other functions }; C.cpp // a lot of other functions template<int i> void C::Func() { // the implementation } // a lot of other functions I know, that it's not the best idea to move template implementation in cpp file (because it won't be seen from other cpp's, which could include the header with the template declaration). But what about private functions? Could anyone tell me if there are cons of implementing of private template functions in a .cpp file? When a function template is used in a way that triggers its