C++ was introduced as a superset of C. Structs were carried over from C, where the semantics of their members was that of public. A whole lot of C code exists, including libraries that were desired to work with C++ as well, that use structs. Classes were introduced in C++, and to conform with the OO philosophy of encapsulation, their members are private by default.

Because a class is a usual way of doing object orientation, which means that member variables should be private and have public accessors - this is good for creating [low coupling](http://en.wikipedia.org/wiki/Coupling_$computer_science$#Low_coupling).  Structs, on the other hand, have to be compatible with C structs, which are always public (there is no notion of public and private in C), and don&#39;t use accessors/mutators.

Probably for backwards compatibility with C structs.  This way structs declared in C code will continue to work the same way when used in C++ code.

Using JQuery animate I would like to operate with css classes, defined somewhere in .css file, not to have to  give all styles params to jquery.animate() explicitly.

I can create a fake (e.g. invisible) element with such a class, read its css properties and give them to jquery.animate()  - does anybody know a better way?


jQuery.animate() with css class only, without explicit styles

If I use GPL-licensed JavaScript components on my website, would it be considered as a release to the public (as client-side code of the components is loaded to users&#39; browsers via http) and I have to &quot;open-source&quot; the whole website?  

So, can we say that the usage of JavaScript components on a website is distribution of the code and it involves the distribution of the whole website code?

Hope, the question is clear and you can help me to understand this aspect of GPL.

Restrictions of GPL on javascript libraries

In C++, why is private the default visibility for members of classes, but public for structs?

default visibility of C++ class/struct members

<p>In C++, why is private the default visibility for members of classes, but public for structs?</p>


Once in a while, I find myself rounding some numbers, and I always have to cast the result to an integer:

    int rounded = (int) floor(value);

Why do all rounding functions (`ceil()`, `floor()`) return a floating number, and not an integer? I find this pretty non-intuitive, and would love to have some explanations!

Why do round() and ceil() not return an integer?

I want to iterate over all files in a directory matching something like `somefiles*.txt`. 

Does `boost::filesystem` have something built in to do that, or do I need a regex or something against each `leaf()`?


Can I use a mask to iterate files in a directory with Boost?

Is it possible to use the `break` function to exit several nested `for` loops?

If so, how would you go about doing this? Can you also control how many loops the `break` exits?



Can I use break to exit multiple nested &#39;for&#39; loops?

I need to iterate over `std::queue`.
www.cplusplus.com says:

&gt; By default, if no container class is specified for a particular queue class, the standard container class template deque is used.

So can I somehow get to the queue&#39;s underlying deque and iterate over it?

std::queue iteration

Which STL container would fit my needs best? I basically have a 10 elements wide container in which I continually `push_back` new elements while `pop_front` ing the oldest element (about a million time). 

I am currently using a `std::deque` for the task but was wondering if a `std::list` would be more efficient since I wouldn&#39;t need to reallocate itself (or maybe I&#39;m mistaking a `std::deque` for a `std::vector`?). Or is there an even more efficient container for my need?

P.S. I don&#39;t need random access

Which STL container should I use for a FIFO?

How can I access an internal class of an assembly?
Say I want to access System.ComponentModel.Design.DesignerHost. Here the DesignerHost is an internal and sealed class. 

How can I write a code to load the assembly and the type?.

How to access internal class using Reflection

Can one write something like:

    class Test(object):
        def _decorator(self, foo):
            foo()
    
        @self._decorator
        def bar(self):
            pass

This fails: self in @self is unknown

I also tried:

    @Test._decorator(self)

which also fails: Test unknown

I would like to temporarily change some instance variables 
in the decorator and then run the decorated method, before
changing them back.







Python decorators in classes

Consider the following code:

    class Base(object):
    
        @classmethod
        def do(cls, a):
            print cls, a
    
    class Derived(Base):
    
        @classmethod
        def do(cls, a):
            print &#39;In derived!&#39;
            # Base.do(cls, a) -- can&#39;t pass `cls`
            Base.do(a)
    
    if __name__ == &#39;__main__&#39;:
        d = Derived()
        d.do(&#39;hello&#39;)

    &gt; $ python play.py  
    &gt; In derived! 
    &gt; &lt;class &#39;__main__.Base&#39;&gt; msg

From `Derived.do`, how do I call `Base.do`? 

I would normally use `super` or even the base class name directly if this is a normal object method, but apparently I can&#39;t find a way to call the classmethod in the base class. 

In the above example, `Base.do(a)` prints `Base` class instead of `Derived` class.


Calling a base class&#39;s classmethod in Python

In Ruby, since you can include multiple mixins but only extend one class, it seems like mixins would be preferred over inheritance.

My question: if you&#39;re writing code which must be extended/included to be useful, why would you ever make it a class? Or put another way, why wouldn&#39;t you always make it a module?

I can only think of one reason why you&#39;d want a class, and that is if you need to instantiate the class. In the case of ActiveRecord::Base, however, you never instantiate it directly. So shouldn&#39;t it have been a module instead?

ruby inheritance vs mixins

How would you find a particular class name inside lots of jar files?

(Looking for the actual class name, not the classes that reference it.)

Find a class somewhere inside dozens of JAR files?

As the title says: do I need to override the `==` operator? how about the `.Equals()` method? Anything I&#39;m missing?

What needs to be overridden in a struct to ensure equality operates properly?

I&#39;m a beginner in C programming, but I was wondering what&#39;s the difference between using `typedef` when defining a structure versus not using `typedef`. It seems to me like there&#39;s really no difference, they accomplish the same goal.


    struct myStruct{
        int one;
        int two;
    };

vs.

    typedef struct{
        int one;
        int two;
    }myStruct;

typedef struct vs struct definitions

I&#39;m using auto-implemented properties. 
I guess the fastest way to fix following is to declare my own backing variable?

    public Point Origin { get; set; }
    
    Origin.X = 10; // fails with CS1612

&gt; Error Message: Cannot modify the return value of &#39;expression&#39; because
&gt; it is not a variable
&gt; 
&gt; An attempt was made to modify a value type that was the result of an
&gt; intermediate expression. Because the value is not persisted, the value
&gt; will be unchanged. 
&gt; 
&gt; To resolve this error, store the result of the expression in an
&gt; intermediate value, or use a reference type for the intermediate
&gt; expression.



Error: &quot;Cannot modify the return value&quot; c#

OK, this is of no serious consequence, but it&#39;s been bugging me for a
while: Is there a reason for the distinction between the `-&gt;` and `.` operators?

Of course, the current rule is that `.` acts on a struct, and `-&gt;` acts on
a pointer-to-struct (or union).  But here&#39;s how it works in practice.
Let `s` be a struct incuding an element `x`, and let `ps` be a pointer to a struct of the same form.

If you write

    s-&gt;x

the compiler will spit out a warning in the way of

&gt; You meant s.x. Please retype that and recompile.

If you write
    
    ps.x
the compiler will spit out a warning in the way of
    
&gt; You meant ps-&gt;x. Please retype that and recompile.

Because the compiler knows the type of both `s` and `ps` at compile time, it has all the information it needs to interpret what the correct operator would be. I suspect that this isn&#39;t like other warnings (like a missing semicolon), in that there is no ambiguity about the correct fix.

So here&#39;s a hypothetical proposal to the C1x standards committee (that would never be considered, because the ISO is on a conservative streak):
    
&gt; Given the expression lhs.rhs, if lhs is a struct or union type,
    then the expression shall refer to the element of lhs named rhs.
    If lhs is of type pointer-to-struct or -union, then this shall be
    interpreted as (*lhs).rhs.

This would certainly save us all time, and make it easier for people to learn C [and I&#39;ve taught enough C to say with authority that learners find the `-&gt;` thing to be either confusing or annoying.] 

There&#39;s even precedent, where C does a handful of similar things.  E.g., for implementation reasons, function declarations are always cast to pointer-to-function, so `f(x,y)` and `(*f)(x,y)` will both work regardless of whether `f` was declared as a function or a pointer to function.

So, my question: what&#39;s wrong with this proposal? Can you think of examples where there would be fatal ambiguity between `ps.x` and `s.x`, or why keeping the mandatory distinction is otherwise useful?


Why does C have a distinction between -&gt; and .?

How to check programmatically if a type is a struct or a class?

I have Python classes, of which I need only one instance at runtime, so it would be sufficient to have the attributes only once per class and not per instance. If there would be more than one instance (which won&#39;t happen), all instance should have the same configuration. I wonder which of the following options would be better or more &quot;idiomatic&quot; Python.

Class variables:

    class MyController(Controller):

      path = &quot;something/&quot;
      children = [AController, BController]
      
      def action(self, request):
        pass

Instance variables:

    class MyController(Controller):

      def __init__(self):
        self.path = &quot;something/&quot;
        self.children = [AController, BController]
      
      def action(self, request):
        pass



Instance variables vs. class variables in Python

If I create a class MyClass and it has some private member say MyOtherClass, is it better to make MyOtherClass a pointer or not?  What does it mean also to have it as not a pointer in terms of where it is stored in memory? Will the object be created when the class is created?

I noticed that the examples in QT usually declare class members as pointers when they are classes.

Class members that are objects - Pointers or not? C++

I know that inline member functions by definition should go into the header. But what if it&#39;s not possible to put the implementation of the function into the header? Let&#39;s take this situation:


File A.h
    
    #pragma once
    #include &quot;B.h&quot;

    class A{
        B b;
    };


File B.h

    #pragma once

    class A; //forward declaration

    class B{
        inline A getA();
    };

Due to the circular include I have to put the implementation of `getA` into

B.cpp

    #include &quot;B.h&quot;
    #include &quot;A.h&quot;

    inline A B::getA(){
        return A();
    }


Will the compiler inline `getA`? If so, which inline keyword is the significant one (the one in the header or the one in the .cpp file)? Is there another way to put the definition of an inline member function into its .cpp file?

C++ inline member function in .cpp file

I&#39;m practicing using mulitple files and header files etc. So I have this project which takes two numbers and then adds them. Pretty simple.

Here are my files:

**main.cpp**

    #include &lt;iostream&gt;
    #include &quot;add.h&quot;

    int main()
    {
        int x = readNumber();
        int y = readNumber();

        writeAnswer(x + y);

        return(0);
    }

**io.cpp**

    int readNumber()
    {
        int x;

        std::cout &lt;&lt; &quot;Number: &quot;;
        std::cin &gt;&gt; x;

        return x;
    }

    void writeAnswer(int x)
    {
        std::cout &lt;&lt; &quot;Answer: &quot;;
        std::cout &lt;&lt; x;
    }

**add.h**

    #ifndef ADD_H_INCLUDED
    #define ADD_H_INCLUDED

    int readNumber();
    void writeAnswer(int x);

    #endif // #ifndef ADD_H_INCLUDED

The error is showing up in io.cpp. The exact errors are:

[![enter image description here][1]][1]

Does anyone have any idea why this may be happening? Thanks.


**EDIT: I made a small project yesterday with the same amount of files (2 .cpp and 1.h) and I didn&#39;t include the iostream header in the other .cpp and it still compiled and ran fine.**


  [1]: https://i.stack.imgur.com/fRKEB.png

cout is not a member of std

I created a class called _`Kwadrat`_. The class has three `int` fields. My _Development Environment_ suggests that I access the fields from _`Kwadrat`_ created objects via the __`::`__ &amp; __`-&gt;`__ operators. I tried both operators, and found that the __`-&gt;`__ operator is able to successfully access the data in the objects fields, although, the same cannot be said for the __`-&gt;`__ operator.
I have also found that the __`.`__ operator will access class members as well. I am confused, and don&#39;t understand why there are three members for accessing object members &amp;/or methods. Can someone please explain to me what the difference is between the three operators?

---

# &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; 1. `-&gt;`
# &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; 2. `::` 
# &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; 3. `.`

---

```C++


    #include &lt;iostream&gt;

    using namespace std;

    class Kwadrat{

    public: 
        int val1,
            val2,
            val3;

        Kwadrat(int val1, int val2, int val3)
        {
            this-&gt;val1 = val1; // Working
            this.val2 = val2;  // Doesn&#39;t Work!
            this::val3 = val3; // Doesn&#39;t Work!
        }
    };


    int main()
    {
        Kwadrat* kwadrat = new Kwadrat(1,2,3);

        cout&lt;&lt;kwadrat-&gt;val1&lt;&lt;endl;
        cout&lt;&lt;kwadrat-&gt;val2&lt;&lt;endl;
        cout&lt;&lt;kwadrat-&gt;val3&lt;&lt;endl;

        return 0;
    }


```


Content Type	Original Author	Original Content on Stackoverflow
Question	S I	View Question on Stackoverflow
Solution 1 - C++	Oren Trutner	View Answer on Stackoverflow
Solution 2 - C++	a_m0d	View Answer on Stackoverflow
Solution 3 - C++	Karl Voigtland	View Answer on Stackoverflow

default visibility of C++ class/struct members

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Restrictions of GPL on javascript libraries

jQuery.animate() with css class only, without explicit styles

Attributions