面向对象C++学习总结-CSDN博客

本文链接：https://blog.csdn.net/m0_63882057/article/details/134707361

面向对象C++ : 函数

1. 缺省值

（1）函数调用时，如果一个参数使用了缺省值，那么后面的所有参数都要使用缺省值。

（2）参数的缺省值在函数声明中指定，而不是在函数定义中指定。在一个文件中，一个参数只能被指定一次缺省值。

print ( x );    // 等价于print ( x, 10)
print ( x, 2 );    //以二进制格式输出x
//print(x1,x2) 中的x2是缺省参数

2.重载函数

（1）两个函数的名字相同，并且在相同的作用域中声明，但是参数表不同，则它们是重载函数。(返回值类型相同)

3.链接指示符 extern

（1）如果程序员希望在C++程序中调用C语言写的函数,这时可以使用链接指示符。

（2）链接指示符不能出现在函数体中，一般放在头文件中比较合适。

//单一语句的链接指示符
  extern "C" void foo( int );
//复合语句形式的链接指示符
  extern "C" {
    int printf(const char*,…);
    int scanf(const char*,…);
  }

 （3）关键字extern用来声明全局对象。extern声明不会引起内存分配，它可以在同一文件中或同一程序的不同文件中多次出现。

面向对象C++ ：类和对象

1.this 指针

（1）区分与局部变量重名的数据成员

（2）返回当前对象

（3）在成员函数中获取当前对象地址

PS : 静态成员函数（static）没有this指针，只能访问静态成员。

class X {
    int m;
public:
    void setVal(int m) { 
      this -> m = m; //区分与函数参数重名的数据成员
    }
    X& add(const X& a)  { 
      m += a.m;
      return *this;     //返回当前对象
    }
    void copy(const X& a) { //拷贝对象
      if (this == &a)//如果是同一对象则无需拷贝
        return;
      m = a.m;     //拷贝操作
    }
};

2.类的友元

（1）在声明友元时要遵循一条规则：友元必须在被访问的类中声明。

//向前声明，声明X是一个类，其完整定义在其他地方
class X;
class Y {
  public:
  //对这个函数声明而言，只需要知道X是一个类型就足够
  void f(X*);    
};
class X { // X的完整声明和定义
  int i;
public:
  void initialize();
  friend void g(X*, int); // 全局函数友元
  friend void Y::f(X*);  // 成员函数友元
  friend class Z;//友元类，Z的所有成员函数都是X的友元
  friend void h();
};

3.构造函数缺省构造函数

（1）构造函数的名字和类名字相同，无返回类型

（2）可以重载，构造函数的形式决定了初始化对象的方式

（3）explicit 关键字在构造函数声明前加上禁止隐式转换

（4）拷贝构造函数……（没搞懂）

class X {
int m,n ;
public:
  X() { m = 0; n = 0;}    //缺省构造函数
  X(int v) { m = v; n = 0; }    //构造函数
  X(int v1, int v2) { m = v1; n = v2; }//构造函数
  explicit X(int v): m(v) {} 
  //只是普通构造函数,不能在需要类型转换时隐式调用
   //其他成员……
};
class Y {
  int m,n ;
public:
  //这也是缺省构造函数的一种形式
  Y(int v1 = 0, int v2 = 0) { m = v1; n = v2; }
  //Y可以通过三种方式调用:Y(),Y(int),Y(int,int)
  //其他成员……
};

4.析构函数

（1）析构函数负责在对象生存期结束时返回相关资源和自动释放资源。当对象离开作用域时，或者用 delete 释放堆上的对象时，析构函数会被自动调用。

（2）析构函数的名字是类名字前加波浪线“~”。析构函数没有返回类型，也没有任何参数。析构函数不能重载。

class Vect {
    int n;
    int* p;
  public:
    Vect(int sz) {
      assert(sz>0);//检查sz是否大于0，否则终止
      n = sz;
      p = new int[n];
    }
   ~Vect(){ delete []p; }//析构函数
   …
  };