【C++笔记】基础

1. C++ 代码基本形式

头文件部分(.h)

• 声明

#include "complex.h" 

• 标准库

#include <iostream.h>

主函数部分（.cpp）

//头文件
main(){
//主函数
}

2. class的声明

• 无模板版本

class point_t
{
public:
    void reset(int a, int b);

public:
    int x;
    int y;
};

//实例化
point_t c1(2,1);

• 有模板版本

//定义
template<typename T>
class point_t
{
public:
    void reset(T a, T b);

public:
    T x;
    T y;
};

//实例化
point_t<int> c2(2,6);

3. 内联函数
   内联可以理解为一种函数的”宏替换“。

// 头文件
class A
{
    public:
    void Foo(int x, int y);
}
 
 
// 定义文件
inline void A::Foo(int x, int y){}

4. 访问级别

class 类名 {
 
   public:
 
  // 公有成员
 
   protected:
 
  // 受保护成员
 
   private:
 
  // 私有成员
 
};

• 公有成员
  公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值。

• 私有成员
  私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。
  默认情况下，类的所有成员都是私有的。

• protected（受保护）成员
  protected（受保护）成员变量或函数与私有成员十分相似，但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的

5. 调用函数方式

• 传引用

#include <iostream>
using namespace std;
 
void test(int &a){
    cout << &a << " " << a << endl;
}
 
int main(void){
    int a = 1;
    cout << &a << " " << a << endl;
    test(a);
    return 0;
}

• 传值

#include <iostream>
using namespace std;
 
void test(int a){
    cout << &a << " " << a << endl;
}
 
int main(void){
    int a = 1;
    cout << &a << " " << a << endl;
    test(a);
    return 0;
}

6. 函数重载

#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
 
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);
 
   return 0;
}

7. 拷贝构造

拷贝构造函数在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
通常用于：
（1）通过使用另一个同类型的对象来初始化新创建的对象。
（2）复制对象把它作为参数传递给函数。
（3）复制对象，并从函数返回这个对象

定义：

类名 (const 类名 &obj) {
   // 构造函数的主体
}

调用：

// 程序的主函数
int main( )
{
   Line line1(10);
 
   Line line2 = line1; // 这里也调用了拷贝构造函数
 
   display(line1);
   display(line2);
 
   return 0;
}

8.析构函数

对于构建对象或分配内存的时候，涉及到了动态分配内存，就需要进行动态分配内存，结束程序之后，也要讲这部分内存给释放掉。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

Line::~Line(void)
{
    cout << "释放内存" << endl;
}

9、面向对象

当面临一些简单的问题的时候，我们可以对一类对象进行处理即可，而面临复杂的问题的时候，就需要让多个类之间产生一定的关系，这就是一种面向对象的思想。
类与类之间的关系大概有

• 复合 （表示 a类 hava b类，其中a为容器）

class a{
b b1;
}

这里可以引出一种设计模式—— 适配模式
而这种模式下的构造是从内到外的，析构是从外到内的

• 委托（表示 a类 有指针指向b类，其中a不一定拥有b）

class a{
b* b1;
}

这样不管b怎么变,a中都可以不变，也成为编译防火墙

• 继承
  -

// 基类
class Animal {
    // eat() 函数
    // sleep() 函数
};


//派生类
class Dog : public Animal {
    // bark() 函数
};

java只有pubic，c++ 有多种
继承的话成员和函数是可以继承下来的，子类具有父类的成分
继承下的构造是由内而外，析构是由外到内
也就是子类的构造是先调用父类的默认构造函数，然后才执行自己
子类的析构的析构是调用自己，然后调用父类的析构函数

10、虚函数

由继承可以引出虚函数的概念，对于非虚函数，虚函数，纯虚函数的区别如下：

• 非虚函数
  不需要子类对其重新定义
• 虚函数
  希望子类重新定义，但已有默认定义
• 纯虚函
  必须让子类进行重新定义

11、多态

多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。
C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

#include <iostream> 
using namespace std;
 
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}