C++之类与对象（完结撒花篇）（下）

#include <iostream>
using namespace std;
class A {
public:
  A() {
    ++_count;
  }
  A(const A& count) {
    ++_count;
 
  }
  ~A() {
    --_count;
  }
  static int getcount() {
    return _count;
  }
private:
  //类里面声明
  static int _count;
};
int A::_count = 520;
int main() {
  cout << A::getcount() << endl; // 输出：520
  A t1; // _count 增加到 521
  A t2(t1); // _count 增加到 522
  cout << A::getcount() << endl; // 输出：522
  // 此时 t1 和 t2 仍然存在
  cout << t1.getcount() << endl;//522
  cout << t2.getcount() << endl;//522
  {
    A t3(t1); // _count 增加到 523
    cout << A::getcount() << endl; // 输出：523
  } // t3 超出作用域, _count 减少到 522
  cout << A::getcount() << endl; // 输出：522
  return 0;
}

#include <iostream>
using namespace std;
 
class B;//前置声明
class A {
  friend void func(const A& a, const B& b);
private:
  int _a = 520;
  int _b = 1314;
};
class B {
  friend void func(const A& a, const B& b);
private:
  int _a = 1314;
  int _b = 520;
};
void func(const A& a, const B& b) {
  cout << a._a << endl;
  cout << b._b << endl;
}
 
int main() {
  A a;
  B b;
  func(a, b);
  return 0;
}

#include<iostream>
using namespace std;
class A
{
  // 友元声明
  friend class B;
private:
  int _a1 = 520;
  int _a2 = 1314;
};
class B
{
public:
  void func1(const A& aa)
  {
    cout << aa._a1 << endl;
    cout << _b2 << endl;
  }
  void func2(const A& aa)
  {
    cout << aa._a2 << endl;
    cout << _b1 << endl;
  }
private:
  int _b1 = 520;
  int _b2 = 1314;
};
int main()
{
  A aa;
  B bb;
  bb.func1(aa);
  bb.func2(aa);
  return 0;
}

#include <iostream>
using namespace std;
 
class A {
private:
    static int _a; // 静态成员
    int _b;        // 非静态成员
public:
    class B {
    public:
        void print(const A& a) {
            cout << _a << endl;   // 访问静态成员
            cout << a._b << endl; // 访问非静态成员
        }
    };
};
 
int A::_a = 520; // 静态成员初始化
 
int main() {
    cout << "A类的大小：" << sizeof(A) << endl; // 输出 A 类的大小
    A::B b; // 创建 B 类的对象
    A aa;   // 创建 A 类的对象
    b.print(aa); // 调用 print 函数
    return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
  A(int a = 0)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
 
  ~A()
  {
    cout << "~A()" << endl;
  }
 
private:
  int _a;
};
 
class Solution {
public:
  int Sum_Solution(int n) {
    //...
    return n;
  }
};
 
bool myfunction(int i, int j) { return (i > j); }
 
int main()
{
  A aa1;  //有名对象
 
  // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
  //A aa2();
 
  // 生命周期只在当前一行
  A(); // 匿名对象
  A(1);
 
  Solution st;
  cout << st.Sum_Solution(10) << endl;
 
  // 为了更方便
  cout << Solution().Sum_Solution(10) << endl;
  return 0;
}

#include <iostream>
using namespace std;
class A {
public:
  A(int a=0)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
  A(const A& aa) 
  :_a(aa._a)
  {
    cout << "A(const A& aa) " << endl;
  }
  A& operator=(const A& aa)
  {
    cout << "A& operator=(const A& aa)" << endl;
    if (this != &aa)
    {
        _a = aa._a;
    }
    return *this;
  }
  ~A() {
    cout << "~A()" << endl;
    }
  void Print()
  {
    cout << "A::Print->" << _a << endl;
  }
 
  A& operator++()
  {
    _a += 100;
 
    return *this;
  }
private:
  int _a ;
};
void f1(A aa)
{}
A f2()
{
  A aa(1);
  ++aa;
  cout << "##########" << endl;
  return aa;
}
int main() {
  A aa1 ;
  aa1.Print();
  //const A& aa2 = 2;
  //A aa3(aa2);
  //A aa1;
  //f1(aa1);
  //cout << endl;
 
  // 隐式类型，连续构造+拷⻉构造->优化为直接构造
  //f1(1);
  // ⼀个表达式中，连续构造+拷⻉构造->优化为⼀个构造
  
  //f1(A(2));
  //cout << endl;
  //cout << "***********************************************" << endl;
  
  // 传值返回
  // 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019）
  // ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022）
  //f2();
  //cout << endl;
  // 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019）
  
     // ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022）
    // A aa2 = f2();
  // cout << endl;
  
     // ⼀个表达式中，连续拷⻉构造+赋值重载->⽆法优化
     aa1 = f2();
   cout << endl;
   A ret = f2();
    ret.Print();
    cout << "*********" << endl << endl;
   //
   return 0;
 
}