指针在数组对象中的基本使用与地址探讨：

这里涉及到类与对象、指针和运算符重载的一些内容：
阅读前可以参考（标星号代表重点）：
*类和对象的进一步了解与使用
**指针及其应用
C++单元学习小结之指针（续），存储空间的分配策略，new和delete运算符，const限定词 结构体（续），枚举
***C++之运算符重载
需要注意的一些内容：
指针的赋值与取地址符的使用：

 	int *p = (int*)&b;  //用指针p指向地址b，即把b的地址赋值给指针p
    cout<<"指针p指向的地址："<<&(*p)<<endl;
   *p=a.b;  //给指针p赋值，现在指针p指向的是地址b，因此也就相当于b=a.b;

运算符重载：

  A& operator=(const A &a){
   
        cout<<"重载"<<endl;
     	b=a.b;
        c=a.c;
        return *this;
    };

关于运算符重载可参考：
***C++之运算符重载
这一部分内容还是十分有趣的（运算符重载这个名词基本上是指C/C++，因为Java是不支持运算符重载的，程序员无法定义+ * 等运算符，没有给程序员自己重载运算符的权利。这也是考虑到Java中面向对象编程（OOP）的原则问题吧），这里给出运算符重载中关于函数调用运算符（）的一些例子：
例一：

//本例参考自菜鸟教程：https://www.runoob.com/cplusplus/function-call-operator-overloading.html
#include <iostream>
using namespace std;

class Distance
{
   
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
   
         feet = 10;
         inches = 20;
      }
      Distance(int f, int i){
   
         feet = f;
         inches = i;
      }
      // 重载函数调用运算符
      Distance operator()(int a, int b, int c)
      {
   
         Distance D;  //定义一个Distance 调用默认构造函数进行初始化，此时feet=10,inches=20;
         cout<<"重载：\t D.displayDistance(): \t";
         D.displayDistance();
         // 进行随机计算（重新赋值）
         D.feet = a + c + 10;
         D.inches = b + c + 100 ;
         return D;
      }
      // 显示距离的方法
      void displayDistance()
      {
   
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }

};
int main()
{
   
   Distance D1(11, 10), D2;

   cout << "First Distance : ";
   D1.displayDistance();

   D2 = D1(10, 10, 10); // invoke operator()
   cout << "Second Distance :";
   D2.displayDistance();

   return 0;
}

例二：

#include <iostream>
using namespace std;
//带状态的函数对象，设定不同的输出流对象和分隔符
class PrintString{
   
	ostream &os;
	char sep;
public:
	PrintString(ostream &o = cout, char c = '\t')
: os(o), sep(c){
   }
	void operator()(const string& str){
   os << str << sep; }
};
int main(){
   
	PrintString welcomeMsg;
	welcomeMsg("Welcome!");
	PrintString errMsg(cerr, '\n');
	errMsg("Error!");
	errMsg("Error!");
	return 0;
}

指针在数组对象中的基本使用与地址探讨：

#include<iostream>
#include<stdio.h>
using namespace std;
class A{
   
    const int b;
    int c;
public:
    A():b(0){
   /*cout<<"调用默认构造函数"<<endl;*/};
    A(int b1,int c1):b(b1),c(c1){
   };
    void show(){
   
        cout<<b<<" "<<c<<endl;
    }

    A& operator=(const A &a){
   
        cout<<"重载"<<endl;
        cout<<"b的地址："<<&b<<endl;
        int *p = (int*)&b;  //用指针p指向地址b，即把b的地址赋值给指针p
        cout<<"指针p指向的地址："<<&(*p)<<endl;
        *p=a.b;  //给指针p赋值，现在指针p指向的是地址b，因此也就相当于b=a.b;
        //b=a.b;
        c=a.c;
        return *this;
    };

};

//A *a[100]; //没有调用默认构造函数，只是以指针的方式存在
A a[100];  //调用默认构造函数，以默认对象存在
int main(){
   
    /* const int i=2; cout<<&i<<endl; int *p = (int*)&i; cout<<&(*p)<<endl; *p=10; cout<<i<<endl; */

    /* A a1 = A(100); a[0]=&a1; (*a[0]).show(); */
    //A a0 = A(i+100,i+120); //如果这样定义那么是直接调用构造函数，没有重载
    A a0;  //这样定义调用默认构造函数，如果对该默认对象a0作出重新赋值修改则调用重载构造函数：a0 = A(i+100,i+120);
    for(int i=0;i<10;i++){
   
        a0 = A(i+100,i+120);
        a[i]=a0;
        a[i].show();
    }
     return 0;
}

result：

同时应注意地址内容：