Ссылки, указатели

#include <iostream>
using namespace std;
 
 
 
class Foo
{
public:
    void                setA(const int a)
    {
        m_a = a;
        updateX();
    }
    void                setB(const int b)
    {
        m_b = b;
        updateX();
    }
    int                 getX() const
    {
        return m_x;
    }
 
private:
    int                 m_a;
    int                 m_b;
    int                 m_x;
 
    void                updateX()
    {
        m_x = m_a + m_b;
    }
};
int main()
{
    Foo obj;
 
    obj.setA(1);
    obj.setB(2);
    cout << obj.getX() << endl;
    obj.setB(5);
    cout << obj.getX() << endl;
}

 int                 getX() const
    {
        return m_x= m_a + m_b;
    }

#include <iostream>
#include <functional>
using namespace std;
int main() {
    int a=1;
    int b=2;
    auto c=[&a, &b](){return a+b;};
    std::cout<<" before a="<<a<<", b="<<b<<", c="<<c()<<std::endl;
    a=3, b=4;
    std::cout<<" after a="<<a<<", b="<<b<<", c="<<c()<<std::endl;
    return 0;
}

#include <iostream>
#include <vector>
/////////////////////////////////////////////////////////////////////
typedef std::vector < int   >   T_int_vect;
/////////////////////////////////////////////////////////////////////
struct  T_sum
{
    //---------------------------------------------------------------
    T_int_vect  int_vect_;
    int         sum_;
    //---------------------------------------------------------------
public:
    //---------------------------------------------------------------
    T_sum( int size )
        :
        int_vect_   ( size ),
        sum_        ()
    {}
    //---------------------------------------------------------------
    void    set
        (
            int     ind,
            int     val
        )
    {
        int     &   cur_var     =   int_vect_[ ind ];
 
        if  (
                    ind     >=  0
                &&  ind     <   int_vect_.size()
            )
        {
 
            sum_        -=  cur_var;
            sum_        +=  val;
            cur_var     =   val;
        }
    }
    //---------------------------------------------------------------
    void    print()
    {
        std::cout   <<  sum_
                    <<  std::endl;
    }
    //---------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////
int     main()
{
    T_sum   sum(2);
 
    sum.set(0,1);
    sum.print();
 
    sum.set(1,2);
    sum.print();
 
    sum.set(0,2);
    sum.print();
 
    sum.set(1,3);
    sum.print();
 
    sum.set(111,3);
    sum.print();
}

#include <iostream>
#include <set>
using namespace std;
struct WatchingValue;
struct LazzySumSet
{
set<WatchingValue*>sumSet;
};
 
struct WatchingValue
{
static int summa;
int value;
static LazzySumSet lazzySumSet;
WatchingValue(int val)
{
value=val;
summa+=val;
lazzySumSet.sumSet.insert(this);
}
WatchingValue& operator=(int rhs)
{   
summa+=rhs-value;
value=rhs;
return *this;
}
WatchingValue& operator=(WatchingValue& rhs)
{   
summa+=rhs.value-value;
value=rhs.value;
return *this;
}
};
 
int WatchingValue::summa=0;
LazzySumSet WatchingValue::lazzySumSet;
 
int main()
{
WatchingValue a=1, b=2, c=3, d=4, e=5;
cout<<WatchingValue::summa<<endl;//15
a=3;
cout<<WatchingValue::summa<<endl;//17
b=a;
cout<<WatchingValue::summa<<endl;//18
cout << endl;
    system("pause");
    return 0;
}

#include <iostream>
/////////////////////////////////////////////////////////////////////
class   T_summand
{
    //---------------------------------------------------------------
    static  int     sum_;
    int             val_;
    //---------------------------------------------------------------
public:
    //---------------------------------------------------------------
    T_summand( int  val )
        :
        val_()
    {
        *this   =   val;
    }
    //---------------------------------------------------------------
    T_summand   &   operator=( int  val )
    {
        sum_    -=  val_;
        val_    =   val;
        sum_    +=  val_;
        return  *this;
    }
    //---------------------------------------------------------------
    T_summand   &   operator=( T_summand    s )
    {
        return  *this   =   s.val_;
    }
    //---------------------------------------------------------------
    static  void    print_sum()
    {
        std::cout   <<  sum_
                    <<  std::endl;
    }
    //---------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////
int     T_summand::sum_     =   0;
/////////////////////////////////////////////////////////////////////
int main()
{
    T_summand::print_sum();
 
    T_summand   a   =   1;
    T_summand::print_sum();
 
    T_summand   b   =   2;
    T_summand::print_sum();
 
    a   =   b;
    T_summand::print_sum();
 
    a   =   b   =   3;
    T_summand::print_sum();
 
    b   =   4;
    T_summand::print_sum();
}