打印 · 面向对象编程（C++）一码知天下(合集版)

第一章：从面向过程到面向对象的过渡案例

PSO作业参考demo(C++)

内容说明：粒子群优化算法(PSO)作业源码参考，包含PSO类定义、类实现、辅助函数和主函数。

PSO.h — 粒子群算法类定义

#ifndef _PSO_H_
#define _PSO_H_

const int DIMENSION=30;   //函数优化的维度(自变量个数)

/*--------------------------------------------------*
                   PSO类定义--粒子个体类
*---------------------------------------------------*/
class PSO
{
  //------------------PSO类数据成员---------------
private:
  //1.粒子个体信息
  double x[DIMENSION];//粒子位置向量
  double v[DIMENSION];//粒子速度向量
  double fitness;//粒子适应度数值

  //2.粒子局部最优信息
  double pbestx[DIMENSION];//粒子局部最优位置
  double pbestfitness; //粒子局部最优适应度数值

  //3.粒子群全局最优信息(共享信息)
  static double gbestx[DIMENSION];//全局最优位置
  static double gbestFintness;//全局最优适应度值

  //------------------PSO类函数成员---------------
public:
  PSO();//构造函数
  ~PSO();//析构函数

  //普通函数(获取粒子个体的相关信息)
  double* getX();//获得粒子的位置向量
  double* getV();//获得粒子的速度向量
  double& getFitness();//获得粒子的适应度
  double* getPbestX();//获得粒子的局部最优位置向量
  double& getPbestFitness();//获得粒子的局部最优适应度数值

  //普通函数:初始化位置和速度向量
  void initi(double xmin, double xmax, double vmin, double vmax);

  //普通函数:计算粒子的适应度(待优化的函数的值)
  double computeFitness(double x[], int dim);

  //普通函数:更新子局部最优和全局最优信息
  void updatePbestX();//更新粒子个体局部最优位置
  void updateGbestX();//更新粒子群体的全局最优位置

  //普通函数:更新粒子的速度和位置向量-生成新的位置
  void updateV(int iter);
  void updateX(int iter);

  //-----------------------------------------------------

  //静态函数:获取全局最佳粒子信息
  static double* getGbestX();//获得全局最佳位置向量
  static double& getGbestFitness();//获得全局最佳适应度数值

  //静态函数:输出全局最佳粒子信息
  static void printGbestX();
  static void printGbestFitness();
};

#endif

PSO.cpp — 粒子群算法类实现

#include <iostream>
#include <cmath>
#include <cstdlib>
#include "PSO.h"
#include "function.h"

using namespace std;


//初始化类中的静态数据成员
double PSO::gbestx[DIMENSION] = {0.0};//全局最优位置初始化
double PSO::gbestFintness=pow(2,1024);//全局最优适应度值初始化,一个较大的值


//外部全局变量导入本文件,以供使用
extern int MAX_ITER;

extern double xmax;
extern double xmin;


extern double vmax;
extern double vmin;

//--------------------PSO类的函数定义------------------------------


PSO::PSO()
{
  //cout << "调用构造函数完成初始化" << endl;
}


PSO::~PSO()
{
  //cout << "调用析构函数完成对象释放" << endl;
}

double * PSO::getX()
{
  return x;//返回位置首地址
}

double * PSO::getV()
{
  return v;
}

double & PSO::getFitness()
{

  return fitness;
}

double * PSO::getPbestX()
{
  return pbestx;
}

double & PSO::getPbestFitness()
{
  return pbestfitness;
}

void PSO::initi(double xmin, double xmax, double vmin, double vmax)
{
  //初始化粒子个体的位置和速度
  for (int i = 0; i < DIMENSION; i++)
  {
    x[i] = xmin + (rand() / (32767 + 1.0)) *(xmax - xmin);
    v[i] = vmin + (rand() / (32767 + 1.0))*(vmax - vmin);
  }


  //计算当前粒子最初的适应度
  fitness = computeFitness(x,DIMENSION);


  //初始化粒子最初的局部最优位置和适应度
  for (int i = 0; i < DIMENSION; i++)
  {
    pbestx[i] = x[i];
  }

  pbestfitness = fitness;

}


//适应度:某个函数f的数值(计算结果越小说明对应的解越好)
double PSO::computeFitness(double x[], int dim)
{
  fitness = sphere(x, dim);//函数Sphere作为测试函数,其他函数自行测试
  //fitness = Rosenbrock(x, DIMENSION);//函数Rosenbrock作为测试函数
  //fitness = Ackley(x, DIMENSION);
  //fitness = Griewanks(x, DIMENSION);


  return fitness;
}

//更新局部最优位置
void PSO::updatePbestX()
{
  if (fitness<pbestfitness)
  {
    pbestfitness = fitness;

    for (int i = 0; i < DIMENSION; i++)
    {
      pbestx[i] = x[i];
    }
  }
}


//更新全局最优位置
void PSO::updateGbestX()
{
  if (pbestfitness<=gbestFintness)
  {
    gbestFintness = pbestfitness;

    for (int i = 0; i < DIMENSION; i++)
    {
      gbestx[i] = pbestx[i];
    }
  }
  else;
}

void PSO::updateV(int iter)
{
  //更新公式参数
  double w = 0.9 - 0.5*iter / MAX_ITER;
  double c1 = 2.0;
  double c2 = 2.0;

  //注意r1,r2是随机生成的小数,需要将其放在for内,每次都产生新的随机数,随机性越高,求解精度越高
  for (int i = 0; i < DIMENSION; i++)
  {
    v[i] = w * v[i] + c1 *rand()/(32767 + 1.0)*(pbestx[i] - x[i]) + c2 * rand() / (32767 + 1.0)*(gbestx[i] - x[i]);

    //速度越界判断
    if (v[i]<=vmin || v[i]>=vmax)
    {
      v[i] = (vmax - vmin)*rand() / (32767 + 1.0);

    }
    else continue;
  }

}


void PSO::updateX(int iter)
{
  for (int i = 0; i < DIMENSION; i++)
  {
    x[i] = x[i] + v[i];

    //位置越界判断
    if (x[i] <= xmin || x[i] >= xmax)
    {
      x[i] = xmin+(xmax - xmin)*double(rand()/RAND_MAX);

    }
    else continue;
  }

}

//-----------------静态函数的定义--------------------

double * PSO::getGbestX()
{
  return gbestx;
}

double & PSO::getGbestFitness()
{
  return gbestFintness;
}

void PSO::printGbestX()
{
  cout <<endl<<"输出当前最好的解:" << endl<<endl;

  for (int dim = 0; dim < DIMENSION; dim++)
  {
    cout << "gbestX[" << dim << "] = " << gbestx[dim] << endl;

  }
  cout << endl;
}

void PSO::printGbestFitness()
{
  cout << "全局最优解的精度: " << gbestFintness << endl;
  cout << endl;
}

main.cpp — PSO主函数

/*************************************************
** 功能 : 粒子群优化算法演示
** 作者 : tsingke
** 时间 : 2019-11-22 / 10:54
***************************************************/

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <windows.h>

#include "PSO.h"
#include "function.h"

using namespace std;

//算法迭代参数设置
int POPSIZE = 40;        //种群个体数目
int MAX_ITER = 7500;     //迭代次数


double accuracy = 1e-60; //搜索精度,误差精度,可以自己改


//搜索范围设置(位置范围,速度范围)
double xmax = 10;
double xmin = -10;

double vmax = 10;
double vmin = -10;

bool success = 0;
/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  srand((unsigned)time(NULL));//产生伪随机数种子

  //1. 在堆上生成PSO类的对象数组,即粒子种群,共POPSIZE个个体
  PSO *swarm=new PSO[POPSIZE];


  //2. 初始化粒子群内所有粒子个体的信息(位置,速度,..等)
  for (int i = 0; i < POPSIZE; i++)
  {
    swarm[i].initi(xmin,xmax,vmin,vmax);
  }

  //3. 循环迭代-搜索目标函数的全局最优解

  cout << "---------------算法开始迭代-------------------" << endl;

  for (int iter = 0; iter < MAX_ITER; iter++)
  {
    for (int id = 0; id < POPSIZE; id++)
    {
      swarm[id].updatePbestX();//更新个体局部最优位置
      swarm[id].updateGbestX();//更新群体全局最优位置


      swarm[id].updateV(iter);//更新个体速度

      swarm[id].updateX(iter);//更新个体位置

      swarm[id].computeFitness(swarm[id].getX(),DIMENSION);//计算个体适应度


    }

    //判断是否达到要求
    if (PSO::getGbestFitness() <= accuracy)//达到设定的精度,中途输出结果,并停止后续迭代
    {
      cout << "搜索到符合精度的解(如下),算法停止搜索" << endl;

      PSO::printGbestX();       //输出全局最优解向量
      PSO::printGbestFitness(); //输出全局最优解的精度
      success = 1;
      break;//跳出循环,停止迭代
    }


    cout << "迭代到第" << iter << "代, 本代最佳适应度数值(误差精度)= " << PSO::getGbestFitness()<<endl;

  }

  //4. 输出实验结果(未达到设定精度,依然输出结果)
  if (success==0)
  {

    PSO::printGbestX();//输出全局最优解向量

    PSO::printGbestFitness();//输出搜索精度

  }

  //5. 释放申请的堆上的动态存储空间
  delete[] swarm;



  system("pause");

  return 0;
}

function.h — 测试函数声明

#ifndef FUNCTION_H
#define FUNCTION_H

double sphere(double x[], int dim);
double Rosenbrock(double x[], int dim);
double Ackley(double x[], int dim);
double Griewanks(double x[], int dim);

#endif

function.cpp — 测试函数实现

#include <cmath>
#include <cstdlib>
#include "function.h"

//Sphere函数
double sphere(double x[], int dim)
{
  double sum = 0;
  for (int i = 0; i < dim; i++)
  {
    sum += x[i] * x[i];
  }
  return sum;
}

//Rosenbrock函数
double Rosenbrock(double x[], int dim)
{
  double sum = 0;
  for (int i = 0; i < dim - 1; i++)
  {
    sum += 100 * (x[i+1] - x[i]*x[i])*(x[i+1] - x[i]*x[i]) + (x[i]-1)*(x[i]-1);
  }
  return sum;
}

//Ackley函数
double Ackley(double x[], int dim)
{
  double sum1 = 0, sum2 = 0;
  for (int i = 0; i < dim; i++)
  {
    sum1 += x[i] * x[i];
    sum2 += cos(2 * 3.1415926 * x[i]);
  }
  return -20 * exp(-0.2 * sqrt(sum1/dim)) - exp(sum2/dim) + 20 + 2.718281828;
}

//Griewanks函数
double Griewanks(double x[], int dim)
{
  double sum = 0, prod = 1;
  for (int i = 0; i < dim; i++)
  {
    sum += (x[i]*x[i])/4000;
    prod *= cos(x[i]/sqrt(i+1));
  }
  return sum - prod + 1;
}

Chapt_1_ReadData：C++文件读取演示

内容说明：演示如何使用C++的文件输入输出流从文件中读取数据、排序后再写入另一个文件。

c++读取文件.cpp

#include <iostream>
#include <fstream>
#include <cstdlib> //qsort在此头文件中声明
using namespace std;
const int MAX_NUM = 1000;
int a[MAX_NUM]; //存放文件中读入的整数
int MyCompare(const void * e1, const void * e2)
{ //用于qsort的比较函数
     return *((int *)e1) - *((int *)e2);
}
int main()
{
    int total = 0;//读入的整数个数
    ifstream srcFile("in.txt",ios::in); //以文本模式打开in.txt备读
    if(!srcFile) { //打开失败
        cout << "error opening source file." << endl;
        return 0;
    }
    ofstream destFile("out.txt",ios::out); //以文本模式打开out.txt备写
    if(!destFile) {
        srcFile.close(); //程序结束前不能忘记关闭以前打开过的文件
        cout << "error opening destination file." << endl;
        return 0;
    }
    int x;
    while(srcFile >> x) //可以像用cin那样用ifstream对象
        a[total++] = x;
    qsort(a,total,sizeof(int),MyCompare); //排序
    for(int i = 0;i < total; ++i)
        destFile << a[i] << " "; //可以像用cout那样用ofstream对象
    destFile.close();
    srcFile.close();
    return 0;
}

chapt_1_ScoreSystem：学生成绩管理系统（C语言风格，面向过程）

内容说明：本章是第一章上机实验框架参考，用C语言风格的面向过程代码实现学生成绩管理系统，为后续转向OOP做铺垫。

main.c — 学生成绩管理系统主函数

#define  _CRT_SECURE_NO_WARNINGS

/*************************************************
** 功能 : 学生成绩管理系统
** 作者 : Qingke Zhang/tsingke@sdnu.edu.cn
** 版本 : v1.0
** 版权 : GNU General Public License(GNU GPL)
/**************************************************/


#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "score.h"

/*----------------------------------*
    Main Function
*-----------------------------------*/

int main()
{

  printf("******************************\n");
  printf("       学生成绩管理分析系统        \n");
  printf("         Qingke Zhang            \n");
  printf("******************************\n\n");

  /*-1.变量初始化-*/
  int N = 0;            //学生总数
  SS  *pstu = NULL;    //学生数组-结构体数组指针实现

  //2.读取学生信息
  pstu = readDataFromFile(&N);

  /*-3.计算学生总成绩（总成绩 = 0.2*平时成绩 + 0.8*期末成绩)--*/
  calcuScore(pstu, N);

  /*-4.根据学生成绩排名-*/
  sortScore(pstu, N);

  /*-5.按照排名输出学生信息-*/
  printOut(pstu, N);

  /*-6.释放动态内存空间-*/
  free(pstu);


  system("pause");
  return 0;
}

score.h — 学生管理头文件

/*************************************************
* Head File   : SCORE.h
* File Usage  : 学生管理系统头文件
* Create Time : v1.0
/**************************************************/

#ifndef __SCORE_H__
#define __SCORE_H__


#include <stdio.h>

/*----------------------------------*
     学生信息-结构体设计
*-----------------------------------*/

typedef struct student
{
  char number[10];  //学号
  char name[10];    //姓名
  float dailyScore;   //平时成绩
  float finalScore;   //期末成绩
  float generalScore; //总评成绩

}SS;


/*---------------函数声明-------------------*/

//1.读取学生基本数据
void readData(SS stu[], int N);
SS* readDataFromFile(int *N);

//2.计算N个学生各自总成绩
void calcuScore(SS stu[], int N);


//3.根据总评成绩排名
void sortScore(SS stu[], int N);


//4.按照一定的格式输出N个学生的完整信息
void printOut(SS stu[], int N);

#endif

score.c — 学生管理函数实现

/*************************************************
** 源文件   : score.c
** 功能说明 : Function Definitions
** 创建版本 : v1.0
/**************************************************/

/*----------------头文件--------------*/
#define  _CRT_SECURE_NO_WARNINGS
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include "SCORE.h"

/*----------------函数定义-------------*/

//1.1手动输入学生基本数据
void readData(SS stu[], int N)
{

  printf("请按照如下格式输入学生信息：学号,姓名,平时成绩,期末成绩\n");

  for (int i = 0; i < N; i++)
  {
    printf("第%d个学生:", i + 1);
    scanf("%s %s %f %f", &stu[i].number, &stu[i].name, &stu[i].dailyScore, &stu[i].finalScore);
    printf("\n");
  }

  printf("------成绩录入完毕!--------\n");

}

//1.2从文件里读取学生基本数据
SS* readDataFromFile(int *N)
{

  printf("\n\n------第一步: 从文件读取学生的成绩信息--------\n\n");

  SS *stu;// 开辟新空间,存取文件中的每个学生信息

  FILE *fp = NULL;
  int count = 0;
  int index = 0;

  fp = fopen("data.txt", "r");

  //1.获取学生数目
  if (fp != NULL)
  {
    fscanf(fp, "%d", &count);
    *N = count;
  }
  else
  {
    printf("failed to open the info file\n");
    getchar();
  }

  printf("学生数目为:%d\n", count);


  //2.给所有学生分配存储空间
  stu = (SS*)malloc(count * sizeof(SS));


  //3.读取每条学生的信息
  while ((!feof(fp)))
  {

    //读入文件数据到内存
    fscanf(fp, "%s%s%f%f\n", (stu[index].number), (stu[index].name), &stu[index].dailyScore, &stu[index].finalScore);

    //输出排序后的学生信息
    printf("* 学号：%s  姓名:%s    平时成绩：%4.2f分    期末成绩:%4.2f分\n", (stu[index].number), (stu[index].name), stu[index].dailyScore, stu[index].finalScore);

    index++;
  }

  getchar();

  fclose(fp);

  return stu;
}

//2.计算N个学生各自的总评成绩
void calcuScore(SS stu[], int N)
{


  printf("\n\n------第二步: 计算每个学生的总评成绩--------\n\n");

  for (int i = 0; i < N; i++)
  {

    stu[i].generalScore = 0.2*stu[i].dailyScore + 0.8*stu[i].finalScore;
    printf("* 学号：%s  姓名:%s    总成绩:%4.2f分\n", (stu[i].number), (stu[i].name), stu[i].generalScore);

  }

  getchar();
}


//3.根据总评成绩排名
int cmpBigtoSmall(const void *a, const void *b)
{

  SS *aa = (SS *)(a);
  SS *bb = (SS *)(b);



  if ((*aa).generalScore < (*bb).generalScore)  return 1;

  else if ((*aa).generalScore > (*bb).generalScore)  return -1;

  else
    return 0;

}

void sortScore(SS stu[], int N)
{

  qsort(&(stu[0]), N, sizeof(stu[0]), cmpBigtoSmall);

}

//4.按照一定的格式输出N个学生的信息
void printOut(SS stu[], int N)
{

  printf("\n------第三步: 根据总成绩输出学生排名信息!------\n\n");

  for (int i = 0; i < N; i++)
  {

    printf("第%d名信息 学号：%s  姓名:%s    总成绩:%4.2f分\n", i + 1, &(stu[i].number[0]), &(stu[i].name[0]), stu[i].generalScore);
  }

  getchar();

}

data.txt — 测试数据

6
201720398 zhang 84.7 96
201720224 wang 78 86
201711034 zhao 80 86
201711045 liu 69 75
201724397 TomHanks 85 90
201700925 Jeny 90 96

第二章：C++与C（C++新增语法特性）

内容说明：本章展示C++相对C新增的语法特性，包括内联函数、命名空间、new/malloc、引用、异常处理、const、默认参数等。

inlineFunction.cpp — 内联函数

/*************************************************
** 功能 : 内联函数的使用
** 作者 : tsingke
** 时间 : 2019-9-24 / 00:42
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>
#include <ctime>
#include <cmath>

using namespace std;

const int run = 100000000;



 int multiply_1(int x, int y)
{


   return x*y;


}


 inline int multiply_2(int x, int y)
{


   return x*y;



}
/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  int t=0;


  int a = 1;
  int b = 2;


  /*----------------------------------*
              普通函数调用时间统计
  *-----------------------------------*/
  int ss_1, ss_2;

  clock_t start_1, end_1;

  start_1 = clock();

  while (t<run)
  {
     ss_1 = multiply_1(a++, b++);

    //cout << a << "^2 + " << b << "^2 = " << ss << endl;
     t++;

  }
  end_1 = clock();


  cout << "普通函数执行总时间: " <<1.0*(end_1 - start_1)  << endl;


  /*----------------------------------*
      内联函数调用时间统计
    *-----------------------------------*/
  clock_t start_2, end_2;

  start_2 = clock();

  t = 0;
  while (t < run)
  {
    ss_2 = multiply_2(a++, b++);
    //cout << a << "^2 + " << b << "^2 = " << ss << endl;
    t++;

  }
  end_2 = clock();


  cout << "内联函数执行总时间: " << 1.0*(end_2 - start_2) << endl;





  system("pause");

  return 0;
}

namespace.cpp — 命名空间

/*************************************************
** 功能 : namespace
** 作者 : tsingke
** 时间 : 2019-9-23 / 21:33
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>
#include <string>

using namespace std;

namespace one
{

  int id;
  double salary;
}


namespace two
{

  int id;
  double salary;
}

namespace three
{

  int id;
  double salary;
  string address;
}
/*----------------------------------*
          Main Function
*-----------------------------------*/

using namespace one;

int main()
{


  /*-全部导入法-*/
  id = 2018;

  salary = 100000;


  /*-随用随取法-*/

  two::id = 2019;
  two::salary = 50000;



  /*-部分导入法-*/

  using three::id;

  id = 100;

  cout << "one::id = "<< one::id << endl;

  id = 999999;
  cout << "two::id = " <<id<< endl;

  cout << "one::id = "<< one::id << endl;

  //address = "sdnu";
  three::address = "sdnu";


  cout << three::address << endl;



  system("pause");

  return 0;
}

new-malloc.cpp — new与malloc对比

/*************************************************
** 功能 : new和malloc的使用演示
** 作者 : tsingke
** 时间 : 2019-10-7 / 12:34
***************************************************/

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <windows.h>

using namespace std;


/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  /*----------------------------------*
              使用malloc 和 free
  *-----------------------------------*/

  int *p1;

  p1= (int*)malloc(sizeof(int) * 10);



  memset(p1, 0, 10*sizeof(int));//初始化为0

  for (int i = 0; i < 10; i++)
  {
    cout << p1[i] << " ";
  }

  cout << endl;



  //初始化
  for (int  i = 0; i < 10; i++)
  {
    p1[i] = i;

    cout << (p1[i]) << " ";
  }

  cout << endl;


  /*-输出各个元素的物理存储地址-*/

  for (int i = 0; i < 10; i++)
  {
    cout << "地址: " << &p1[i] << endl;

  }

  cout << endl;

  free(p1);



  int *p3 = (int*)calloc(10, sizeof(int));

  for (int i = 0; i < 10; i++)
  {
    cout << p3[i] << " ";
  }

  cout << endl;


  /*----------------------------------*
              使用new 和 delete
  *-----------------------------------*/


  int *p2;
  p2 = new int[10];

  for (int i = 0; i < 10; i++)
  {
    p2[i] = i*i;

    cout << p2[i] <<" ";
  }

  cout << endl;

  /*-输出各个元素的物理存储地址-*/

  for (int i = 0; i < 10; i++)
  {
    cout << "地址: " << &p2[i] << endl;

  }

  delete[] p2;



  /*----多维数组的申请-----*/

  int(*pt)[5] = new int[4][5];//pt[4][5]

  //初始化的方法
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 5; j++)
    {
      pt[i][j] = i * j;

      cout << pt[i][j]<<" ";
    }

    cout << endl;
  }



  int(*ptt)[4][6] = new int[3][4][6];//ptt[3][4][6]

  delete[] pt;

  delete[] ptt;




  system("pause");

  return 0;
}

referenceDemo1.cpp — 引用基础

/*************************************************
** 功能 : 引用的用法
** 作者 : tsingke
** 时间 : 2019-10-8 / 14:50
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;


void swap(int &x, int &y)
{
  int temp;
  temp = x;
  x = y;
  y = temp;

}


int& func(int &x, int &y)
{


  int x = x + y;


  return x;

}

/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{


  int a = 88;

  int b = 66;

  int &r = a;

  int &rrrrr = a;




  //r = 99;

  cout << "a= " <<a<< endl;
  cout << "r= " <<r<< endl;

  cout << "a的地址=" << &a << endl;
  cout << "r的地址=" << &r << endl;
  cout << "rrrr的地址=" << &rrrrr << endl;




  cout << "a= " << a << endl;
  cout << "b= " << b << endl;


  int c = a+b;
  swap(c, b);


  cout << "a= " << a << endl;
  cout << "b= " << b << endl;




  func(a, b);

  int xx= func(a, b) + 18;

  func(a, b) = 4;//x=4;







  system("pause");

  return 0;
}

referenceDemo2.cpp — 引用深入

/*************************************************
** 功能 : 引用的使用演示案例demo
** 作者 : tsingke
** 时间 : 2019-10-8 / 10:08
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;


double sum(int x, int &y)
{

  x++;
  y++;

  return x + y;
}


int& sumref(int x,int &y)
{

  y = x + y;



  return y;
  //注意:不要返回局部变量的引用,因为局部变量离开所在函数就被系统释放回收了,即使起别名也没有任何使用价值.
  // 可以返回某个类型为引用的形参,例如这里的y就是一个引用形参类型,可以返回.


}


int func(int *p, int &r,int o)
{

  *p = 666;//通过指针改变指向的数值
   r = 888;//通过引用改变指向的数值
   o = 999;


   cout << "指针*p的数值= " << *p << endl;
   cout << "引用r的数值= " << r << endl;
   cout << "整型o的数值= " << o << endl;

  return 0;
}

/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  //1. 什么是引用:变量的别名

  int a1 = 100;
  int a2 = 200;

  int &r = a1;//声明时就要给引用初始化
       r = a2;


  cout << "a的地址:" << &a1 << endl;
  cout << "r的地址:" << &r << endl;


  //2.哪些量不可以是引用

  //void va;    //不可以建立void变量的引用
  //int &&r = a;//不可以建立引用的引用
  //int & *p = a;//不允许使用指向指针的引用
  //int & arry[10] = a;//不允许使用引用的数组



  //3. 引用的作用1: 做函数的形参,做函数的返回类型

  sum(a1, a2);

  cout << "a1的数值= " << a1 << endl;
  cout << "a2的数值= " << a2 << endl;


   //4. 引用的作用2:作为函数的返回类型(例如:cin>>x执行完后返回的是cin对象的引用,还是cin)




  sumref(a1, a2);//独立的函数调用语句

  int s = sumref(a1, a2) + 8;//引用作为操作数

  sumref(a1, a2) = 3000;//引用作为左边的数值



  //5. 引用和指针的区别

  //引用:变量的别名, 本身直接操作指向的数据
  //指针:带有类型的地址,远程间接操作指向的数据

  int m = 1;
  int n = 2;
  int o = 3;

  func(&m, n,o);

  cout << "m = " << m << "  n= " << n << endl;


  system("pause");

  return 0;
}

try-catch_1.cpp — try-catch原理剖析

/*************************************************
** 功能 : try-catch 原理剖析
** 作者 : tsingke
** 时间 : 2019-10-7 / 20:17
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;



void func1(int a);
void func2(int a);
void func3(int a);
void func4(int a);


//函数调用关系: fun1-->func2-->func3-->func4
/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  int x;

  cout << "请输入整数x= ";
  cin >> x;

  try
  {
    func1(x);

  }
  catch (const int e)
  {
    cout << "主函数内处理异常" << endl;
  }


  system("pause");

  return 0;
}

//-------------------子函数定义--------------------

void func1(int a)
{

  if (a == 1)
  {
    throw 1;
  }


  try
  {
    func2(a);

  }
  catch (int e)
  {
    cout << "func1 内处理异常" << endl;

  }


  cout << " i am func1" << endl;


}


void func2(int a)
{
  if (a == 2)
  {
    throw 2;
  }

  try
  {
    func3(a);

  }
  catch (int e)
  {
    cout << "func2 内处理异常" << endl;

  }
  cout << " i am func2" << endl;


}

void func3(int a)
{
  if (a == 3)
  {
    throw 3;
  }
  try
  {
    func4(a);

  }
  catch (int e)
  {
    cout << "func3 内处理异常" << endl;

  }
  cout << " i am func3" << endl;


}

void func4(int a)
{
  if (a == 4)
  {
    throw 4;//如果引发异常,下面的输出语句将不会执行
  }

  cout << " i am func4" << endl;

}

try-catch_2.cpp — try-catch课堂演示

/*************************************************
** 功能 : try-catch课堂演示
** 作者 : tsingke
** 时间 : 2019-10-7 / 12:51
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;



double add(int a, int b)
{

  if (a+b == 0)
  {
    throw -1;
    cout << "-1"<< endl ;


  }
  return double(a + b);

}

double subtraction(int a, int b)
{
  if (a - b == 0)
  {
    throw - 2;
    cout << "-2" << endl;

  }

  return double(a - b);
}

double multiplication(int a, int b)
{
  if (a * b == 0)
  {
    throw - 3;
    cout << "-3" << endl;

  }

  return double(a * b);
}

double divide(int a, int b)
{

  if (b == 0)
  {
    throw - 4;

    cout << "-4"<< endl ;

  }

  return double(1.0*a / b);
}


double rootsum(int a,int b)
{

  if (a<0 && b<0)
  {
    throw -1.2;

    cout << "-5" << endl;

  }

  return double(sqrt(a)+sqrt(b));
}
/*----------------------------------*
          Main Function
*-----------------------------------*/



int main()
{

  cout << "try- catch 使用演示" << endl ;
  int a, b;

  do
  {
    try
    {
      cout << endl<< "------输入两个数,输出他们的四则运算结果-----" << endl;

      cout << "a = "; cin >> a;

      cout << "b = "; cin >> b;


      cout << "a+b = " << add(a, b) << endl;


      cout << "a-b = " << subtraction(a, b) << endl;
      cout << "a*b = " << multiplication(a, b) << endl;
      cout << "a/b = " << divide(a, b) << endl;

      cout << "sqrt(a)+sqrt(b)= " << rootsum(a, b) << endl;


    }
    catch (const int e)
    {
      switch (e)
      {
      case -1: cout << "异常发生: a+b == 0"; break;
      case -2: cout << "异常发生: a-b == 0"; break;

      case -3: cout << "异常发生: a*b == 0"; break;

      case -4: cout << "异常发生: a/b == null"; break;

      default:
        break;
      }

    }
    catch (const double f)
    {
      cout << f << endl;
      cout << "异常发生: a<0 或b <0 " << endl;
    }


  } while (1);



  system("pause");

  return 0;
}

constDemo.cpp — const基础

/*************************************************
** 功能 : const demo
** 作者 : tsingke
** 时间 : 2019-9-24 / 08:33
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;


int sum(const int *p1, const int *p2)
{
  //*p1 = 222;


  return (*p1 + *p2);

}


/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{




  int a = 666;
  int b = 888;

  int c=sum(&a, &b);


  cout << "c= " << c << endl ;





  system("pause");

  return 0;
}

const与指针.cpp — const与指针

#include <iostream>
using namespace std;

int main()
{
    int i=100;
    int j=200;

    //1.指向常量的指针：指向的量是常量，故*p1不可变，但p1可变
#if 1

    const int *p1;

    *p1 = j;//错误
    p1=&j;  //正确


#endif

    //2.常指针：指针自己是常量， 故p2不可变， 但*p2可变
#if 1

    int* const p2=&i;

     p2 = &j; //错误
    *p2=j;    //正确


#endif

    //3.指向常量的常指针： 指针是常量，指针指向的也是常量，故都不能修改。
#if 1

    int const * const p3 =&i;

    p3=&j;//错误
    *p3=j;//错误

#endif
    return 0;
}

defaultArgument_1.cpp — 默认形参（基础）

/*************************************************
** 功能 :默认形参函数演示
** 作者 : tsingke
** 时间 : 2019-10-8 / 14:29
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;



void func(int a, int b,int c)
{

  cout << a << endl;
  cout << b << endl;
  cout << c << endl;

}

void func_1(int a, int b=600, int c=800)
{

  cout << a << endl;
  cout << b << endl;
  cout << c << endl;

}






/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{




  int a = 1;


  int b = 2;
  int c = 3;

  int a_1 = 3;


  //func(a, b, c);

  func_1(a);
  func_1(a, b);
  func_1(a, b, c);





  system("pause");

  return 0;
}

defaultArgument_2.cpp — 默认形参（深入）

/*************************************************
** 功能 : 函数默认形参演示
** 作者 : tsingke
** 时间 : 2019-9-23 / 23:29
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;

void plot(int x , int y , int z = 0, char color = 'B');


//void plot(int x, int y, int z, char color)
//{
//
//  cout << "坐标x= " << x << endl;
//  cout << "坐标y= " << y << endl;
//  cout << "坐标z= " << z << endl;
//
//  cout << "颜色 c= "  <<color << endl ;
//
//}



//void plot(int x=0, int y=1, int z=0, char color='B')
//{
//
//  cout << "------图形的基本信息如下所示-------" << endl ;
//  cout << "坐标x= " << x << endl;
//  cout << "坐标y= " << y << endl;
//  cout << "坐标z= " << z << endl;
//
//  cout << "颜色 c= " << color << endl;
//
//}




/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{


  int a = 3, b = 4, c = 5;
  char color = 'R';

  plot(a, b, c, color);//一一对应的方式

  plot(a, b);//





  system("pause");

  return 0;
}



//定义带默认形参的函数时,不要带上默认值,只在声明时带上!!!!
void plot(int x, int y, int z, char color)
{

  cout << x << y << z << color<< endl;


}

第三章：类与对象（上）

内容说明：本章进入面向对象编程核心——类与对象，包含this指针、构造函数、类对象使用、友元函数、浅拷贝与深拷贝。

this.cpp / constructor.cpp — 构造函数课堂演示

/*************************************************
** 功能 : 构造函数课堂演示
** 作者 : tsingke
** 时间 : 2019-10-21 / 18:18
***************************************************/

#include <iostream>
#include <cstdlib>

using namespace std;

class date
{
public:

    void inition(int y,int m, int d);
    date(); //无参构造函数

    date(int y, int m=1, int d=1);//有参构造函数(可以给定默认值)

    date(const date &r);//拷贝构造函数

    void display();

    ~date();

private:
    int year;
    int month;
    int day;
};

void date::inition(int y, int m, int d)
{
    this->year =y;
    this->month =m;
    this->day=d;
}

date::date()
{
    cout << "无参构造函数被调用" << endl;

}

date::date(int y,int m, int d)
{
    year = y;
    month = m;
    day = d;

    cout << "有参构造函数被调用" << endl;
}

date::date(const date & r)
{
    this->year = r.year;
    this->month = r.month;
    this->day = r.day;

    cout << "拷贝构造函数被调用" << endl;

}

void date::display()
{
   cout<<year<<"-"<<month<<"-"<<day<<endl;

   //cout<<"指针this指向地址:"<<this<<endl;

}


date::~date()
{
    cout << "*析构函数调用:" <<this<<endl;


}



/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

    date a;//对象a
    cout<<"对象a的地址:"<<&a<<endl;

    a.display();

    date b(2019);//对象b
    b.display();


    date c(b);//对象c
    c.display();



    return 0;

}

构造函数的使用(课堂范例).cpp

/*************************************************
** 功能 : 构造函数的使用
** 作者 : tsingke
** 创建 : 2020-11-2
** 版权 : tsingke@sdnu.edu.cn
**************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;

class Date
{

private:
  int year, month, day;

public:
  Date()
  {
    cout << "无参构造函数被调用!" << endl;
  }

  Date(int year, int month, int day)
  {

    this->year = year;
    this->month = month;
    (*this).day = day;
    cout << "普通构造函数被调用!" << endl;
  }

  Date(const Date& r)
  {
    this->year = r.year;
    this->month = r.month;
    this->day = r.day;
    cout << "拷贝构造函数被调用!" << endl;
  }

  ~Date()
  {
    cout << "~析构函数被调用(回车继续)!" << endl;
    getchar();
  }


};


//全局函数,返回类的对象类型
Date func(Date val)
{

  cout << "func()is called" << endl;

  return val;//调用拷贝构函,情形三
}


/*----------------------------------*
*         Main Function
*-----------------------------------*/

int main()
{

  Date lastday;//调用无参构函

  Date today(2020, 11, 1);//调用有参构函

  Date tommory(today);//调用拷贝构函(情形一)

  func(tommory);//调用拷贝构函(情形二)

  today = Date(2021,11,11);//调用普通有参构函,不会调用拷贝构函


  system("pause");

  return 0;
}

triangleDemo.cpp — 三角形类的演示

/*************************************************
** 功能 : 类的演示
** 作者 : tsingke
** 时间 : 2019-10-15 / 15:12
***************************************************/

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <windows.h>

using namespace std;





class triangle
{

private:
  double a;
  double b;
  double c;

public:


  void inti(int, int, int);

  bool isTriangle();

  double perimeter();

  double area();

  int typeTriangle();

  void ModifyA(int);


};

bool triangle::isTriangle()
{

  if ((a + b) > c && (a + c) > b && (b + c) > a)
  {
    return true;
  }

  else
    return false;
}

void triangle::inti(int s1, int s2, int s3)
{

  a = s1;
  b = s2;
  c = s3;

  if (isTriangle() == false)
  {
    cout << "无法构成三角形,退出程序!" << endl;

    exit(0);
  }

}

double triangle::perimeter()
{

  return a + b + c;

}


double triangle::area()
{

  double  p = perimeter() / 2.0;

  return sqrt(p*(p - a)*(p - b)*(p - c));

}

int triangle::typeTriangle()
{

  if (pow(a, 2) + pow(b, 2) == pow(c, 2))
  {
    return 1;
  }
  else if (pow(a, 2) + pow(b, 2) < pow(c, 2))
  {
    return 2;
  }
  else
  {
    return 3;
  }




}

void triangle::ModifyA(int s)
{
  a = s;//间接修改边长a的数值
}


/*----------------------------------*
      Main Function
*-----------------------------------*/

int main()
{
  triangle t;

  int ta, tb, tc;


  //t.a = 666;//无法直接访问私有数据

  t.ModifyA(6666);

  cout << "pleaes input three edges: " << endl;

  cin >> ta;
  cin >> tb;
  cin >> tc;

  t.inti(ta, tb, tc);


  cout << "周长=" << t.perimeter() << endl;
  cout << "面积= " << t.area() << endl;

  if (t.typeTriangle() == 1)
  {
    cout << "直角三角形" << endl;

  }
  else if (t.typeTriangle() == 2)
  {
    cout << "锐角三角形" << endl;

  }
  else
    cout << "钝角三角形" << endl;



  system("pause");

  return 0;
}

类对象的使用-一码知天下.cpp

/*************************************************
** 功能 : 对象的使用
** 作者 : tsingke
** 时间 : 2019-11-4 / 18:02
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;


class date
{
  //1.类的变量记心间
private:
  int year;
  int month;
  int day;

public:

  //2. 三构一析放在前
  date();
  date(int year, int month, int day);
  date(const date &r);
  ~date();


  //3.普函定义按需添

  int getYear();
  int getMonth();
  int getDay();

  void setYear(int y);
  void setMonth(int m);
  void setDay(int d);



  void display();


};

//---------------类成员函数的实现----------------------
date::date()
{
  cout << "++无参构造函数被调用++" << endl;
  year = 2019;
  month = 01;
  day = 01;
}

date::date(int year, int month, int day)
{
  cout << "++有参构造函数被调用++" << endl;

  this->year = year;
  this->month = month;
  this->day = day;
}

date::date(const date & r)
{
  this->year = r.year;
  this->month = r.month;
  this->day = r.day;
}

date::~date()
{
  cout << "--析构函数被调用--" << endl;
}

int date::getYear()
{
  return year;
}

int date::getMonth()
{
  return month;
}

int date::getDay()
{
  return day;
}

void date::setYear(int y)
{
  this->year = y;
}

void date::setMonth(int m)
{
  this->month = m;
}

void date::setDay(int d)
{
  this->day = d;

}

void date::display()
{
  cout << year << "年" << month << "月" << day << "日" << endl;
}


//==================全局函数=========================


void print(date &r)
{
  cout << r.getYear() << "年" << r.getMonth() << "月" << r.getDay() << "日" << endl;
}


//对象作为参数(对象,对象指针,对象引用)
void objectAsArgument(date t, date * p, date & r)
{
  //传值形式无法修改原对象内容,但可以访问到原对象内相同的数据
  t.setYear(2050);
  t.setMonth(10);
  t.setDay(24);


  //通过指针修改原对象内容
  p->setYear(2035);
  p->setMonth(6);
  p->setDay(1);


  //通过引用修改原对象内容
  r.setYear(2050);
  r.setMonth(10);
  r.setDay(24);

}

/*----------------------------------*
      Main Function
*-----------------------------------*/


//使用方法: 把#if 后面的0改成1即可调试对应区域代码

int main()
{



#if 0
  //----------------------第一块演示: 对象的数组----------------------------------

  //a1.栈对象数组的定义

  //date array_1[3];//调用无参构造函数
  //date array_2[3] = { date(2019,10,1),date(2019,10,2) };//按需调用构造函数

  //a2.堆对象数组的定义
  //date *parray_1 = new date[3];//调用无参构造函数

  date *parray_2 = new date[3];//调用无参构造函数

  date *temp = parray_2;

  parray_2[0] = date(2020, 1, 1);
  parray_2[1] = date(2020, 1, 2);
  parray_2[2] = date(2020, 1, 3);



  //b. 对象数组元素访问对象成员的方式(2种)

  for (int i = 0; i < 3; i++)
  {

    //array_1[i].display();//直接访问对象成员法


    //array_2[i].display();//直接访问对象成员法


    //(parray_1++)->display();//间接访问对象成员法

    (parray_2++)->display();//间接访问对象成员法
    //循环体执行完本语句后,如果在程序里用delete[]parray_2就会报错,因为
    //此时parray_2不再指向动态数组的首地址,而是第3个元素的地址,所以
    //建议使用直接访问的方式比较稳妥!!!!




  }

  delete[]temp;

#endif

#if 0
  //---------------------第二块演示:对象的指针----------------------------------

  date s1;

  //1. 探索指针的初始化,建议定义指针变量时务必对其进行初始化,否则后患无穷!!
  date *p = NULL;//如果这里令 date *p=1,就会报错,这里的NULL实际是0,本质上是个地址,即NULL=0=00000000
  cout << "p指向到哪里:" << p << endl;

  p = 0;//这里的0,本质上是个地址,即0=00000000,如果改成p=1,报错,因为1不是内存地址.
  cout << "p指向到哪里:" << p << endl;


  //2.指针的两种用法
  p = &s1;

  s1.getYear();


  (*p).getYear();
  p->getYear();

#endif


#if 0
  //----------------------第三块演示:对象的引用----------------------------------

  date today;

  date &r = today;

  today.display();
  r.display();


  date tomorrow(2030, 10, 1);


  //r自始至终都是today的引用,不会变化
  //通过改变today或r的值,彼此内容都会发生变化
  r = tomorrow;

  today.display();



  //对象引用的核心作用:作为函数的形参

  print(today);

#endif

#if 0

  //----------------------第四块演示:.对象作为参数(对象,对象指针,对象引用)----------------------------------

  date day_1(1970, 1, 1);
  date day_2(1970, 1, 1);
  date day_3(1970, 1, 1);


  objectAsArgument(day_1, &day_2, day_3);

  day_1.display();//day_1对象没有被修改(数值)
  day_2.display();//day_2对象已经被修改(指针)
  day_3.display();//day_3对象已经被修改(引用)

#endif

  //-----------------------------------Over---------------------------------------------------------------

  system("pause");//如果想查看析构函数被调用情况,请单步调试,一直F10即可.

  return 0;
}

classDemo.cpp — 类的综合演示

/*************************************************
** 功能 : 类的演示
** 作者 : tsingke
** 时间 : 2019-10-15 / 08:58
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;

//设计一个学生结构体

struct student_s
{
  string name;
  int id;
  int age;
  double high;
  double weight;
  double salary;
};

class date
{

public:
  int year;

private:

  int month;
  int day;

public:
  void display()
  {
    cout << year << "年" << month << "月" << day << "日" << endl;
  }
  void initi(int y, int m, int d);

  void modifyear();

  int getmonth()
  {
    return month;
  }
};

void date::initi(int y,int m,int d)
{
  year = y;
  month = m;
  day = d;
}


/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{


  struct student_s wang;

  wang.name = "wanger";
  wang.id = 2018;
  wang.age = 20;
  wang.high = 1.75;
  wang.weight = 60;
  wang.salary = 7000;


  date today;


  today.initi(2019, 10, 15);

  today.display();


  today.year = 2020;

  cout<<today.getmonth()<<endl;


  system("pause");

  return 0;
}

Distribution of the objects and object members.cpp — 对象分布规律

/*************************************************
** 功能 : 对象的访问
** 作者 : tsingke
** 时间 : 2019-10-21 / 22:27
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;



class date
{


private:

  int year;
  int month;
  int day;

public:
  void setDate(int y, int m, int d)
  {
    year = y;
    month = m;
    day = d;

  }
  void display()
  {

    cout << "year=" << year << " month= " << month << " day=" << day << endl;
  }

  void address()
  {

    cout << "year的地址:" << &this->year << endl;
    cout << "month的地址:" <<& this->month << endl;
    cout << "day的地址:" << & this->day<< endl;


  }


};

/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()

{


  date a;
  date *p =&a;

  //1.对象直接访问其内容
  a.setDate(2019, 10, 22);
  a.display();



  (*p).display();


  //2. 指针间接访问对象内容
  p->display();




  //3. 探索类对象内数据成员的存放规律

  date b;
  date c;

  b.setDate(2019, 12, 31);
  c.setDate(2020, 12, 31);

  cout << endl;

  //3.分析对象的分布规律(高地址-低地址)
  cout << "对象b的地址" << &b << endl;
  cout << "对象c的地址" << &c << endl;

  cout << endl;

  //4.分析对象内变量的分布规律(低地址--高地址)
  b.address();
  //c.address();

  system("pause");

  return 0;
}

friend-global function.cpp — 友元全局函数

#include <iostream>

using namespace std;

class date
{
    int year;
    int month;
    int day;

public:
    date(int y,int m,int d) ;
    ~date();
    void display();
    friend void birthdayCheck(date &r1,date &r2);// 友元"流浪"函数的声明
};

date::date(int y, int m, int d)
{
   this->year=y;
    this->month=m;
            this->day=d;
   cout<<"this is a constructor function " <<endl;
}

date::~date()
{
   cout<<"this is a deconstrucor"<<endl ;
}

void date::display()
{
   cout<<year<<"年-"<<month<<"月-"<<day<<"日"<<endl;
}

void birthdayCheck(date &r1,date &r2)
{

    if((r1.year==r2.year)&&(r1.month==r2.month)&&(r1.day==r2.day))
    {
        cout<<"是同一天生日"<<endl;
    }
    else
    {
        cout<<"不是同一天生日"<<endl;
    }
}

int main()
{


    date zhang(2000,10,1);
    date wang(2000,10,1);

    zhang.display();

    wang.display();


    birthdayCheck(zhang,wang);

    return 0;//

}

shallow-deep — 浅拷贝与深拷贝

student.h

#pragma once
class student
{

private:
  int id;
  char *name; //申请动态内存的信号

public:
  //1. 构造函数，析构函数

  student(int id, const char *user_name);

  student(const student &r);

  ~student();


  //2. 普通函数
  void display();
};

student.cpp

#include "student.h"
#include <iostream>

using namespace std;


student::student(int id, const char *user_name)
{
  cout << "构造函数被调用" << endl;
  this->id = id;

  if (user_name!=NULL)
  {
    int len = strlen(user_name);

    name = new char[len + 1];

    strcpy(name, user_name);

  }



}

student::student(const student & r)
{
  this->id = r.id;

   // this->name = r.name;//浅拷贝<-----栈上操作

  if (r.name!=NULL)//深度拷贝<---堆上操作
  {
    int len = strlen(r.name);

    this->name = new char[len + 1];

    strcpy(this->name, r.name);
  }
}


student::~student()
{
  cout << "--析构函数被调用--" << endl;

  if(name != NULL)
  {
    delete[] name;
  }


}

void student::display()
{
  cout << "学号id  = " << id << endl;

  cout << "姓名name= " << name << endl;


}

main.cpp

/*************************************************
** 功能 : 浅拷贝-深拷贝代码演示
** 作者 :
** 版本 : 2019-10-29 / 19:18
** 版权 : GNU General Public License(GNU GPL)
/**************************************************/

#include <iostream>
#include <cstdlib>
#include "student.h"


using namespace std;



/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{
  char *name = new char[20];

  strcpy(name, "bill gates");

  student zhang(2019,name);

  student wang = zhang;//调用系统默认的拷贝构造函数



  zhang.display();

  wang.display();





  system("pause");

  return 0;
}

shallow-deep-copy — 另一种浅拷贝与深拷贝实现

student.h

#ifndef STUDENT_H
#define STUDENT_H

//析构函数的作用:
/***
 *
 * 完成对象销毁前的清理工作,释放构造器申请的堆空间
 * 无返回类型
 * 自动被调用
 * 不能被重载,因为析构函数本身没有任何参数,所以"同名不同参"的条件永远无法被满足)
 */

class student
{
public:
    student();
    student(char*na,int age,int gender);

    student(const student &r);
    ~student();
    void display();

private:
    char *name;
    int age;
    bool gender;
};

#endif // STUDENT_H

student.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "student.h"
#include<cstring>
#include<iostream>

using namespace  std;

// 使用构造函数完成对象的初始化
student::student()
{

}

student::student(char *na, int age, int gender)
{

    cout << "+构造函数被调用" << endl;
    if (na != NULL)
    {
        int len = strlen(na);

        this->name = new char[len + 1];

        strcpy(this->name, na);
    }

    this->age = age;

    this->gender = gender;

}

student::student(const student &r)
{
    cout << "+拷贝构造函数被调用" << endl;

    //系统默认对位拷贝
    //this->name = r.name;//浅拷贝,仅涉及栈上的数据对位拷贝,不涉及堆

    if (r.name!=NULL)//深度拷贝--仅仅针对有堆数据拷贝的情况
    {

        this->name = new char[strlen(r.name) + 1];

        strcpy(name, r.name);
    }


    this->age = r.age;
    this->gender = r.gender;

}

student::~student()
{
    //删除堆空间
    if (this->name != NULL)
    {
        delete[] name;
    }

    cout << "~析构函数被调用" << endl;


}

void student::display()
{
    cout << "name  = " << name << endl;
    cout << "age   = " << age << endl;
    cout << "gender= " << this->gender << endl;

}

main.cpp

#include <iostream>
#include "student.h"
using namespace std;

int main()
{
    char *name =new char[20];

    name="Bill Gates";

    student stu1(name,60,1);
    stu1.display();

    student stu2=stu1;
    stu2.display();






    return 0;
}

第四章：类与对象（下）— static 与 const

内容说明：本章深入探讨类的static成员和const成员，包含const静态与全局常量、常成员函数、常对象、静态成员变量、静态成员函数。

const — 常量

const_demo_1(常量const本质剖析).cpp

/*************************************************
** 功能 : const本质：const栈常量与const全局区常量 能否被修改?
** 作者 : tsingke
** 时间 : 2019-11-11 / 23:36
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;


const int global = 100;

/*----------------------------------*
      Main Function
*-----------------------------------*/

int main()
{

#if 1
  //情形1: const修饰的栈上的常量,通过指针可以间接实现对其修改

  const int  local = 10;//下面程序所有的local在编译时都被替换为10

  cout << "const local = " << local << endl;

  //意图通过指针修改这个常量

  int *p1 = (int*)(&local);

  *p1 = 20;

  cout << "const local = " << *p1 << endl;

  cout << "local地址   = " << &local << endl;
  cout << "p1指向的地址 = " << p1 << endl;

#endif

  //---------------------------------------------

#if 0
//情形2:const修饰的全局区上的常量,通过指针无法对其进行修改(编译时会报异常)

  int *p2 = (int*)(&global);

  cout << "const global = " << global << endl;

  *p2 = 200;

  cout << "const global = " << *p2 << endl;

  cout << "global地址  = " << &global << endl;
  cout << "p2指向的地址 = " << p2 << endl;

#endif


  system("pause");

  return 0;
}

const_demo_2(常成员变量,常函数,常对象).cpp

/*************************************************
** 功能 : 常数据成员,常成员函数,常对象
** 作者 : tsingke
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;

class circle
{

private:

  double R;
  const double pi;//常成员变量
  static int TotalCount;
public:

  circle(double r = 0):pi(3.1415926)
  {
    this->R = r;

  }


  //修改半径
  double getR()     //普通函数
  {
    cout << "getR()被调用" << endl;
    return R;
  }

  //访问半径
  double getR() const  //常成员函数,重装函数
  {
    cout << "getR()const被调用" << endl;

    //setR(2);//报错,因为常函数不能访问普通非常函数,只能常对常访问
    return R;
  }

  //访问半径
  void setR(double r)
  {
    R = r;
  }

  //输出面积
  double area()
  {
    getR();//普通函数可以访问常函数
    return pi * R*R;
  }

  //输出周长
  double circumstance()
  {
    return 2 * pi*R;
  }

};

int circle::TotalCount = 0;//定义初始化静态成员变量


/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{


  circle A;//普通的对象
  const circle B(3.5);//常对象,带参初始化(务必要初始化)
  const circle C;//常对象,采用构函默认值初始化

  cout<< "A.getR() = "<< A.getR()<<endl;//普通对象调用对应的非常函数,如果非常函数不存在,就调用常函数
  cout<< "B.getR() = " <<B.getR()<<endl;//常对象调用常函数


  A.setR(5.4);//正确,普通对象可访问所有类内普通函数
  //B.setR(12);//报错,常对象不能访问普通函数,必须访问常成员函数



  system("pause");

  return 0;
}

static — 静态成员

complex.h

#ifndef COMPLEX_H
#define COMPLEX_H

class complex
{

private:
  double x;
  double y;
  static int count;//私有的静态成员变量

public:
  complex(int px,int py);
  ~complex();
  void display();

  static int s;//公有的静态成员变量
  static void showcount();//
};

//int complex::s=0;    //类外初始化,务必注意,如果将类采用多文件编程时,静态成员变量的定义不要放在.h文件中,放在.cpp文件中,否则会引发多重定义问题.
//int complex::count=0;//类外初始化,必注意,如果将类采用多文件编程时,静态成员变量的定义不要放在.h文件中,放在.cpp文件中,否则会引发多重定义问题.

#endif // COMPLEX_H

complex.cpp

#include "complex.h"
#include <iostream>

//初始化静态数据成员
int complex::s=0;    //类外初始化,务必注意,如果将类采用多文件编程时,静态成员变量的定义不要放在.h文件中,放在.cpp文件中,否则会引发多重定义问题.
int complex::count=0;


//-------c/c++中的static本质：持久化存储，实现数据共享功能-------------
using namespace std;

//extern int global;

complex::complex(int px, int py):x(px),y(py)
{
  cout<<"Constructor is called"<<endl;
  count++;
  cout<<"cout = "<<count<<endl;

}

complex::~complex()
{
  cout<<"destructor is called"<<endl;
  count--;
  cout<<"cout = "<<count<<endl;

}

void complex::display()
{
  cout<<"x = "<<x<<endl;
  cout<<"y = "<<y<<endl;

  showcount();//普通函数可以直接访问静态函数

}

void complex::showcount()//本质是类外的全局函数
{
   cout<<"count = "<<count<<endl;

  //this->x=2;//静态成员函数无法访问非静态成员

   //display();//会报错，不允许在静态函数访问非静态函数（因为普通函数背后是对象）

}

main.cpp

#include <iostream>
#include "complex.h"
using namespace std;


//int global=10;   //可以在整个程序的多个文件内共享的全局变量，只要其他位置将其声明为外部变量即可，exter int global;

static int s_ga=0;//仅在本文件内进行共享的全局变量，外部文件无法访问外联性，external link

void func(int t)
{
  static int s_la=0;//static 修饰局部变量，la此时就具有了持久化存储能力，直到程序结束一直存在；初始化工作只在开始执行1次，之后不再初始化

  s_la=s_la+t;

  cout<<"s_la= "<<s_la<<endl;

}

int main()
{
 //-------------------1-----------------------
#if 1
  //1. 测试静态全局变量的本质

  s_ga=2;

  s_ga++;

  cout<<"s_ga="<<s_ga<<endl;

#endif

 //-------------------2-----------------------
#if 1
  //2. 测试静态局部变量的本质

  for (int i = 0; i < 10; ++i)
    {
      func(i);
    }
  cout << "Hello World!" << endl;
#endif

  //------------------3------------------------

#if 1

  //3. static 在类中的使用（静态数据成员、静态成员函数）

  //静态变量：本质为外部的全局变量，现在将其拉到类内，实现封装
  //静态函数：本质为外部的全局函数，专门为访问类内静态变量而设置。

  complex ca(2,5);
  complex cb(1,4);


  //3.1 类直接访问公有静态数据成员
  cout<<"complex::s= "<<complex::s<<endl;

  //3.1 对象访问公有静态数据成员
  cout<<"ca.s = "<<ca.s<<endl;
  cout<<"cb.s = "<<cb.s<<endl;

  //~~~~

  //3.2 类通过静态成员函数访问私有静态数据成员（专门为类服务的）
  complex::showcount();

  //3.2 对象通过访问静态成员函数访问私有静态数据
  ca.showcount();
  ca.display();

#endif

  //cout<<"complex::count"<<complex::count<<endl;
  return 0;
}

第五章：类关系—继承

内容说明：本章研究类与类之间的继承关系，包含三种继承方式、同名冲突、多继承构造函数调用次序、菱形继承、赋值兼容性。

chapt5_class relations/inheritance/README.md

1-inheritance_定义和三种继承理解.cpp

/*************************************************
** 功能 : 类三种继承的定义形式,三种继承关系的深刻理解
** 作者 : tsingke
** 时间 : 2019-11-25 / 21:37
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;


class A            //作为基类
{
//------------------成员数据------------------

public:
  int a_pub;
protected:
  int a_pro;
private:
  int a_pri;
//------------------成员函数------------------
public:
  A(int pub=0, int pro=0, int pri=0)  //有参构造
  {
    cout << "A() is called" << endl;

    this->a_pub = pub;
    this->a_pro = pro;
    this->a_pri = pri;


  }
  ~A()//析构函数
  {
    cout << "~A() is called" << endl;
    getchar();

  }

  void dispaly()
  {
    cout << "基类对象成员数据:" << a_pub << " " << a_pro << " " << a_pri<<endl;
  }


};

//--------------------研究三种不同的继承方式------------------------
class B:public A  //公有继承
{
private:
  int bb;

public:
  B(int b=2):A(2,2,2)
  {
    this->bb = b;
    cout << "B() is called" << endl;
  }
  ~B()
  {
    cout << "~B() is called" << endl;
    getchar();

  }

  void display()//探索公有继
  {
    //基类数据传承探索
    a_pub = 200;//a_pub仍为公有数据,子类内可以直接访问
    a_pro = 200;//a_pro仍为保护数据,子类内可以直接访问
    //a_pri = 200;//报错,基类私有成员在子类不可见

    //基类函数传承探索
    A::dispaly();
    cout << "自身添加数据成员: bb = "<<bb << endl;


  }

};

class C: protected A //保护继承
{

private:
  int cc;
public:
  C(int c=3):A(3,3,3)
  {
    cout << "C() is called" << endl;

    this->cc = c;
  }
  ~C()
  {
    cout << "~C() is called" << endl;
    getchar();


  }

  void display()//探索保护继承
  {
    //基类数据传承探索
    a_pub = 300;//a_pub变为保护数据,类内可以直接访问
    a_pro = 300;//a_pro变为保护数据,类内可以直接访问
    //a_pri = 300;//报错,基类私有成员在子类不可见

    //基类函数传承探索
    A::dispaly();
    cout << "自身添加数据成员: cc = " << cc << endl;


  }
};

class D : private A  //私有继承
{

private:
  int dd;
public:
  D(int d = 4): A(4, 4, 4)
  {
    cout << "D() is called" << endl;

    this->dd = d;
  }

  ~D()
  {
    cout << "~D() is called" << endl;
    getchar();

  }
  void display()//探索私有继承
  {
    //基类数据传承探索
    a_pub = 400;//a_pub变为私有数据,子类内可以直接访问
    a_pro = 400;//a_pro变为私有数据,子类内可以直接访问
    //a_pri = 400;//报错,基类私有成员在子类不可见

    //基类函数传承探索
    A::dispaly();
    cout << "自身添加数据成员: dd = " << dd << endl;


  }
};

/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  //功能1:通过比较类的大小,证明无论哪种继承方式都会全盘接受基类成员,包括私有的成员

#if 1

  cout << "基类A的大小为: " << sizeof(A) << endl;
  cout << "--类B的大小为: " << sizeof(B) << endl;
  cout << "--类C的大小为: " << sizeof(C) << endl;
  cout << "--类D的大小为: " << sizeof(D) << endl;

  cout << "---------------------------------" << endl;

#endif


  //功能2:构造函数和析构函数的调用
#if 1
  A a;
  cout << "---------------" << endl;

  B b;
  cout << "---------------" << endl;


  C c;
  cout << "---------------" << endl;


  D d;
  cout << "---------------" << endl;

#endif

  //功能3:三种继承的使用(类外访问探索)

#if 0
  //------------类B--公有继承--类A---------------
  B b;//派生类B的对象

    b.a_pub = 200; //正确, 子类内仍然为公有成员,类内外均可访问
  //b.a_pro = 200; //错误,子类内仍然为保护成员,类内可直接访问,类外不可以
  //b.a_pri = 200; //错误,基类私有成员在子类内外均不可见

  //b.dispaly();   //正确,访问的是子类自身的公有成员
  //b.A::dispaly();//正确, 子类内函数仍然为公有成员,类内外均可访问

#endif

#if 0
  //------------类C--保护继承--类A---------------
  C c;//派生类C的对象
  //c.a_pub = 300;//错误,变为子类保护成员,无法类外直接访问
  //c.a_pro = 300;//错误,变为子类保护成员,无法类外直接访问
  //c.a_pri = 300;//错误,基类私有成员在子类内外均不可见

  //c.display();    //正确,访问的是子类自身的公有成员
  //c.A::dispaly(); //错误,变为子类的保护函数,不可类外访问


#endif

#if 0
  //------------类D--私有继承--类A---------------

  D d;//派生类D的对象

  //d.a_pub = 400; //报错,变为子类的私有成员,无法类外直接访问
  //d.a_pro = 400; //报错,变为子类的私有成员,无法类外直接访问
  //d.a_pri = 400; //报错,基类私有成员在子类内外均不可见

  //d.dispaly();    //报错,变为子类私有成员,无法类外直接访问
  //d.A::dispaly(); //错误,继承后变为子类私有函数,无法类外直接访问

#endif

  system("pause");

  return 0;
}

2-inheritance-父子同名与数据访问方式.cpp

/*************************************************
** 功能 : 类的继承中,父子类间同名冲突问题(单继承)
** 作者 : tsingke
** 时间 : 2019-11-25
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;


class base
{
private:
  int a;
public:
  base(int _a):a(_a)
  {
    this->a = _a;;
  }
  ~base() {}
  int get() { return a; }

};

class derived : public base
{
private:
  int a;
public:
  derived(int _a) :base(_a*10)
  {
    this->a = _a;
  }

  ~derived() {}

  int get() { return a; }

};

/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  base b(10);
  derived d(20);


  //1.冲突解决: 通过域名解析符来访问被子类遮挡的父类的同名成员
  cout<<"d.get()= "<< d.get()<<endl;     //只能访问派生类的get函数(掩盖了基类的get函数)

  cout<<"d.base::get()= "<<d.base::get()<<endl;//访问父类中的同名函数,通过域名解析的方法

  //2.基类指针用法

  cout << "------基类指针指向派生类对象----------" << endl;
  base *pb;
  pb = &d;
  cout<<"pb->get() = "<<pb->get()<<endl;//通过基类指针指向派生类对象, 基类指针仅能访问到被派生类继承过去的成员数据或成员函数

  //3. 基类引用用法
  cout << "------基类引用,引用派生类对象----------" << endl;

  base &r = d;
  cout <<" r.get() = "<< r.get() << endl;//


  system("pause");

  return 0;
}

3-inheritance-多继承与基类构函调用次序问题.cpp

/*************************************************
** 功能 : 类的多继承-同名冲突问题/基类构函调用次序问题
** 作者 : tsingke
***************************************************/

#include <iostream>
#include <cstdlib>
#include <windows.h>

using namespace std;

class base1
{
public:
  int a;
  base1(int _a)
  {
    cout << "base1() is called" << endl;
    this->a = _a;
  }
  ~base1()
  {
    cout << "~base1() is called" << endl;
    getchar();

  }
  void print()
  {
    cout << "base1的a = " << a << endl;
  }
};

class base2
{
public:
  int a;
  base2(int _a)
  {
    cout << "base2() is called" << endl;
    this->a = _a;
  }
  ~base2()
  {
    cout << "~base2() is called" << endl;
    getchar();

  }
  void print()
  {
    cout << "base2的a = " << a << endl;
  }

};



//构造函数调用次序与下面"定义派生类"时各个基类出现的先后顺序有关,与其在文件中定义的顺序无关
class derived : public base2, public base1
{
public:
  int a;
public:
  derived(int _a):base1(_a * 2),base2(_a * 3)

  {
    cout << "derived() is called" << endl;

    this->a = _a;
  }
  ~derived()
  {
    cout << "~derived() is called" << endl;
    getchar();

  }
  void print()
  {
    cout << "derived的a = " << a << endl;
  }
};

/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{


  //1. 派生类访问自己的数据

  derived d(1);

  cout << "d.a = " << d.a << endl;

  d.print();//优先访问派生类的函数

  cout << "-----------------------" << endl;

  //2.派生类对象访问继承自父类的数据成员

  cout << "d.base1::a = " << d.base1::a << endl;
  cout << "d.base2::a = " << d.base1::a << endl;


  cout << "-----------------------" << endl;

  //3. 访问基类中的同名函数

  d.base1::print();//访问基类1中的同名函数

  d.base2::print();//访问基类2中的同名函数





  system("pause");

  return 0;
}

4-inheritance-菱形继承sofabed.cpp

/*************************************************
** 功能 : 类的多继承:菱形继承解决方案-虚继承
** 作者 : tsingke
** 提示 : 绘制派生类成员关系图,不迷路
***************************************************/

#include <iostream>

using namespace std;

//定义家具类(祖先类)
class Furnitrue
{
public:
    void Show()
    {
        cout <<"m_weight " << m_weight << endl;
        cout <<"m_color" << m_color << endl;
    }
  //一个类如果想要让别人来继承,同时要保证自己数据的封装性,那么可以将其定义为protected类型
protected:
    int m_weight;//家具的重量数值(公共属性)
    int m_color; //家具的颜色数值(公共属性)
};

//1.定义沙发类
class Sofa : virtual public Furnitrue
{
public:
    Sofa(int x=50, int y=100)
    {
        m_weight = x;
        m_color = y;
    }
    void sit()
    {
        cout << "Sofa can sit" << endl;
    }

};

//2.定义床类
class Bed : virtual public Furnitrue
{
public:
    Bed(int x=50, int y=100)
    {
        m_weight = x;
        m_color = y;
    }
    void sleep()
    {
        cout << "Bed can sleep" << endl;
    }
};

//3. 定义沙发床类
class SofaBed : public Sofa, public Bed
{
public:
    SofaBed(int x, int y)
    {
        m_weight = x;//只有一份
        m_color = y;//只有一份
    }
};

int main()
{
    SofaBed sb(100, 999);
    sb.sit();
    sb.sleep();
    sb.Show();
    return 0;
}

5-inheritance-赋值兼容.cpp

#include <iostream>

using namespace std;

//赋值兼容(有亲缘关系的数据才可以赋值,晚辈赋值给长辈)

//1派生类对象可以赋值给基类对象
//2派生类对象可以初始化基类的引用
//3派生类对象的地址可以赋值给指向基类的指针

//定义图形类
class Shape
{
public:
    Shape(int x=0, int y=0)
        :m_x(x),m_y(y)
    {

    }
    void Draw()
    {
        cout << "Shape::" << "(" << m_x << "," << m_y << ")" << endl;
    }
protected:
    int m_x;
    int m_y;
};

//定义圆类
class Circle : public Shape
{
public:
    Circle(int x=0, int y=0, int r=0)
        :Shape(x,y),m_radius(r)
    {

    }
    void Draw()
    {
        cout << "Circle::" << "(" << m_x << "," << m_y << ")" << "radius" << m_radius << endl;
    }
protected:
    int m_radius;
};

int main()
{
    //1.派生类对象可以赋值给基类对象
    //Shape s(1,2);
    //s.Draw();
    //Circle c(3,4,5);
    //c.Draw();
    //
    //s = c;
    //s.Draw();


//2.派生类对象可以初始化基类的引用
//    Circle c(3,4,5);

//    Shape & rs = c;
//    rs.Draw();


    //3.派生类对象的地址可以赋值给指向基类的指针
    //Circle c(3,4,5);
    //Shape *ps = &c;
    //ps->Draw();




    //int a = 10;
    //int *pi = &a;
    //char *pc = &a; //这样是不安全的
    //
    //char ch = 'a';
    //int *pi = &ch;//这样是不安全的





    return 0;
}

第六章：多态性

1-静态多态性

内容说明：静态多态性通过函数重载实现，包含普通函数的重载和运算符重载（成员函数法、友元函数法）。

complex.h

#ifndef COMPLEX_H
#define COMPLEX_H

#include <iostream>
using namespace std;

class complex
{
private:
    double real;
    double imag;

public:
    //===================静态多态: 函数重载========================
    complex();
    complex(double r, double i);//构造函数
    complex(const complex &r);
     ~complex();

    void print();
    void print()const;



    //===============静态多态: 运算符重载1-成员函数法===============

     //a.重载加法运算符+(双目运算符)
    complex operator+(const complex &other);


    //b.重载赋值运算符=(双目运算符)-类内重载

    complex operator=(const complex &other);

     //c.重载前++运算符(单目运算符)-类内重载,类外重载均可
    complex operator++();


     //d.重载后++运算符(单目运算符)-类内重载
    complex operator++(int);


    //e.重载函数调用运算符()运算符(单目运算符)-类内重载
    double operator()();

   //===============静态多态: 运算符重载2-友元函数法===============

    //-重载输出运算符<< : 双目运算符,格式"cout<<" 左侧是一个输出流对象cout"
    friend ostream& operator<<(ostream &out, complex &t);

};


#endif // COMPLEX_H

complex.cpp

#include "complex.h"



//-----------------------成员函数-------------------------

complex::complex()
{

}

complex::complex(double r, double i)
{
    this->real =r;
    this->imag =i;
}

complex::complex(const complex &r)
{
    this->real =r.real;
    this->imag = r.imag;
}

complex::~complex()
{

}

void complex::print() const
{


}

complex complex::operator+(const complex &other)
{

    complex temp;

    temp.real = this->real + other.real;
    temp.imag = this->imag + other.imag;

    return  temp;

}

//赋值运算符=
complex complex::operator=(const complex &other)
{
    this->real = other.real;
    this->imag = other.imag;
}

//前++
complex complex::operator++()
{
    ++this->real;
    ++this->imag;

    return *this;

}

//后++
complex complex::operator++(int)
{
    complex temp;//

    temp.real = this->real++;
    temp.imag=this->imag++;

    return  temp;

}

//函数调用符
double complex::operator()()
{
    double sum = this->real * this->real + this->imag *this->imag;

    return  sum;

}


//-----------------------友元函数-------------------------
ostream & operator<<(ostream &out, complex &t)
{
    out<<t.real<<"+" <<t.imag<<"i"<<endl;
}

main.cpp

/*-------------------------------------
 * 功能: 类的静态多态性(函数重载+运算符重载)
 * 作者: tsingke
-------------------------------------*/


//静态多态: 函数重载(同名不同参) + 运算符重载(4种)

#include <iostream>
using namespace std;

#include "complex.h"


//--------------主函数---------------

int main()
{

    //定义复数类的对象
    complex a(6,6);
    complex b(8,8);
    complex c,d,e;


    //1. 重载输出运算符<<, 输出大对象 (双目运算符)
    cout<<"a="<<a<<endl;
    cout<<"b="<<b<<endl;
    cout<<"c="<<c<<endl;



    //2. 重载加法运算符+ (双目运算符),
    c = a + b;//a.operator+(b);
    cout<<c;



    //3. 重载赋值运算符= (如果对象不涉及堆内存资源,不建议重载赋值运算符,使用系统提供的就可以)
    c = a;
    cout<<c<<endl;



    //4. 重载函数调用运算符()  (多目运算符)
    cout<<a()<<endl;//输出距离real^2 +imag^2;





    //5.1 重载后++, 对象a++(后加加)-(单目运算符)

    d=a++;
    cout<<"d=a++; d = "<<d<<endl;



    //5.2 重载前++,对象++b(前加加)-(单目运算符)
    e=++b;
    cout<<"e=++b; e = "<<e<<endl;




    return 0;
}

2-动态多态性

内容说明：动态多态性通过虚函数实现，包含赋值兼容性、虚函数原理、虚析构函数、纯虚函数与抽象类，以及游戏实战案例。

1-预备工作-赋值兼容性.cpp

/*************************************************
** 功能 : 动态多态性--指哪打哪如何实现
** 作者 : tsingke
***************************************************/

#include <iostream>
#include <cstdlib>

using namespace std;
class base
{

private:
  int a;
  int b;
  int c;
public:
  base()
  {
    cout<<"base() is called"<<endl;

  }
  void display()
  {
    cout<<"base-display() is called "<<endl;

  }
};

class derive: public base
{
private:
  int x,y,z;
public:
  derive()
  {
    cout<<"derive() is called"<<endl;
  }
};


/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{


  base father;

  derive son;



  //---------探索赋值兼容性：3种类型---------

  father = son;//赋值兼容性1

  //son = father;//错误， 父类对象不能赋值给派生类对象

  base *p = &son;//赋值兼容性2

  base &r = son;//赋值兼容性3



  father.display();//调用父类函数

  p->display();    //调用父类内的函数

  r.display();     //调用父类内的函数


  /*
   * 赋值兼容性存在的问题：无法通过父类指针访问到子类新添加的同名函数
   * 解决方法：在基类内设置同名函数为虚函数，即可实现"指哪打哪"的效果
   **/



  return 0;
}

2-动态多态性-虚函数-指哪打哪.cpp

/*************************************************
** 功能 : 动态多态性--只要公有继承，长相相同，就能指哪打哪
** 作者 : tsingke
***************************************************/

#include <iostream>
#include <cstdlib>

using namespace std;
class base
{

private:
  int a;
  int b;
  int c;
public:
  base()
  {
    cout<<"base() is called"<<endl;

  }

  virtual void display()
  {
    cout<<"base-display() is called "<<endl;

  }
};

class derive: public base
{
private:
  int x,y,z;
public:
  derive()
  {
    cout<<"derive() is called"<<endl;
  }

  void display()//由于父类同名函数display()为虚函数，因此，子类同名函数自动变为虚函数
    {
      cout<<"derive-display() is called "<<endl;

    }
};


/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{


  base father;

  derive son;



  //--------虚函数实现动态多态性---------

  father = son;//赋值兼容性1

  //son = father;//错误， 父类对象不能赋值给派生类对象

  base *p = &son;//赋值兼容性2

  base &r = son;//赋值兼容性3



  father.display();//调用父类函数

  p->display();    //调用子类内的函数（p指向子类对象，调用子类函数）

  r.display();     //调用子类内的函数（r引用子类对象，调用子类函数）


  /*
   * 赋值兼容性存在的问题：无法通过父类指针访问到子类新添加的同名函数
   * 解决方法：在基类内设置同名函数为虚函数，即可实现"指哪打哪"的效果
   **/



  return 0;
}

3-动态多态性-虚函数原理挖掘.cpp

/*************************************************
** 功能 : 动态多态性--虚函数实现原理
** 作者 : tsingke
***************************************************/

#include <iostream>
#include <cstdlib>

using namespace std;
class base
{

private:
  int a;
public:
  base()
  {
    cout << "base() is called" << endl;

  }

  virtual void display()
  {
    cout << "base-display() is called " << endl;

  }
};

class derive : public base
{
private:
  int x;
public:
  derive()
  {
    cout << "derive() is called" << endl;
  }

  void display()//由于父类同名函数display()为虚函数，因此，子类同名函数自动变为虚函数
  {
    cout << "derive-display() is called " << endl;

  }
};


/*----------------------------------*
      Main Function
*-----------------------------------*/

int main()
{


  base father;

  derive son;


  //-----虚函数通过设置虚函数表实现-----

  cout << "---------------------" << endl;

  cout << "base 类大小为：  " << sizeof(base) << endl;
  cout << "derive类大小为： " << sizeof(derive) << endl;

  cout << "---------------------" << endl;



  //--------虚函数实现动态多态性---------

  father = son;//赋值兼容性1

  //son = father;//错误， 父类对象不能赋值给派生类对象

  base *p = &son;//赋值兼容性2

  base &r = son;//赋值兼容性3



  father.display();//调用父类函数

  p->display();    //调用子类内的函数（p指向子类对象，调用子类函数）

  r.display();     //调用子类内的函数（r引用子类对象，调用子类函数）


  /*
   * 赋值兼容性存在的问题：无法通过父类指针访问到子类新添加的同名函数
   * 解决方法：在基类内设置同名函数为虚函数，即可实现"指哪打哪"的效果
   **/


  getchar();

  return 0;
}

4-动态多态性-虚析构函数.cpp

/*************************************************
** 功能 : 动态多态性--虚析构函数(一虚全虚)
** 作者 : tsingke
***************************************************/

#include <iostream>
#include <cstdlib>

using namespace std;

//--------------------父类----------------------------

class base
{

private:
  int a;
public:
  base()
  {
    cout << "base() is called" << endl;

  }
  //~base(){}//
  virtual ~base()
  {
    cout << "~base() is called" << endl;
  }

  virtual void print()
  {
    cout << "base-print() is called" << endl;
  }


};

//--------------------子类----------------------------
class derive : public base
{
private:
  int *id;
public:
  derive()
  {

    id = new int[10];
    cout << "derive() is called" << endl;
  }
  ~derive()//如果基类析构函数为虚函数,则子类的析构函数全都自动变为虚函数
  {
    cout << "~derive() is called" << endl;
    if (id!=NULL)
    {
      delete[] id;
    }
  }

  virtual void print() //公有继承,长相相同
  {
    cout << "derive-print() is called" << endl;
  }

};


/*----------------------------------*
      Main Function
*-----------------------------------*/

int main()
{


  base *p = new derive; //通过基类指针创建无名对象

  p->print();          // 通过虚函数实现"指哪打哪"的目的

  delete p;             //通过基类指针释放无名对象


  return 0;
}

5-动态多态性-纯虚函数.cpp

/*************************************************
** 功能 : 纯虚函数与抽象类
** 作者 : 张庆科
** 时间 : 2019-12-9
***************************************************/

#include <iostream>
#include <cstdlib>
#include <cmath>    //不要落掉,调用其sqrt()函数
#include <windows.h>

using namespace std;


//----------------抽象类: 图形类-------------------

class shape
{
public:
  virtual double circumstance() = 0;

  virtual double area() = 0; //含有纯虚函数的类就是抽象类

};

//----------------具体类:正方形类-------------------

class squre:public shape
{
private:
  double a;

public:
  squre(int _a) :a(_a)
  {
    cout << "生成正方形对象, 边长 = " << a << endl;
  }
  ~squre() {}

  double circumstance()//基类同名为虚函数,子类相同函数自动变为虚函数(公有继承,长相相同)
  {
    return 4 * a;
  }

  double area()       //基类同名为虚函数,子类相同函数自动变为虚函数(公有继承,长相相同)
  {
    return a * a;
  }

};

//----------------具体类:三角形类-------------------

class triangle:public shape
{
private:
  double a, b, c;
public:
  triangle(double _a, double _b, double _c) :a(_a), b(_b), c(_c)
  {

    if ((a+b<=c) || (a+c<=b) || (b+c <=a))
    {
      cout << "无法构成三角形,请重新输入三条边:" << endl;
      cin >> a;
      cin >> b;
      cin >> c;
    }

    cout << "生成三角形对象, 边长 = " << a <<" "<< b << " " << c<<endl;



  }
  ~triangle() {}

  double circumstance() //基类同名为虚函数,子类相同函数自动变为虚函数(公有继承,长相相同)
  {
    return a + b + c;
  }

  double area()        //基类同名为虚函数,子类相同函数自动变为虚函数(公有继承,长相相同)
  {
    double p = 0.5 * circumstance();

    return sqrt(p*(p - a)*(p - b)*(p - c));

  }

};

//全局函数,输出某个图形的周长和面积
void display(shape *p)
{


  cout << "周长为: " << p->circumstance() << endl;//多态语句(指哪打哪)
  cout << "面积为: " << p->area() << endl;        //多态语句(指哪打哪)

  cout << "------------------------------" << endl;
}



/*----------------------------------*
          Main Function
*-----------------------------------*/

int main()
{

  squre squ(10);         //正方形类对象

  triangle tri(3, 4, 5); //三角形类对象


  //------------1. 抽象类的特性探索----------

  //shape sha;  // 错误, 不可以生成抽象类的对象
  cout << "sizeof(shape) = " << sizeof(shape) << endl;//可以计算抽象类大小

  shape *p;     // 正确, 可以建立抽象类的指针变量
  shape &r = squ;//正确, 可以建立抽象类的对象引用,引用的是派生类对象


  //-----------2. 动态多态特性探索-----------
  cout << endl;

  cout << "正方形的周长和面积:"<<endl;
  display(&squ);//输出正方形的周长和面积, 指哪打哪

  cout << "三角形周长和面积:"<<endl;
  display(&tri);//输出三角形的周长和面积, 指哪打哪




  system("pause");

  return 0;
}

游戏王者争霸-虚函数与动态多态.cpp

/*************************************************
** 功能 : 动态多态实践应用： 王者争霸游戏模拟
** 作者 : tsingke
/**************************************************/


//动态多态：借助虚函数实现

//动态多态条件: 公有继承（public）, 原型相同（基类与子类某个函数原型相同）
//实现的结果  ：指哪打哪

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int killDragon = 0;
int killLion = 0;
int killTiger = 0;

const int MaxDragon = 5;
const int MaxLion = 20;
const int MaxTiger = 30;

const int iter = 100;

//-------------------基类：所有游戏角色的基类------------------------
class Canimal
{
protected:

  double lifeValue; // 生命力，自身的寿命
  double power;     // 攻击力，对其他动物


public:
  virtual void Attack(Canimal *other) {};  //虚函数: 自己主动攻击别人
  virtual void Fightback(Canimal *own) {};//虚函数: 攻击别人时被别人反击自己
  virtual void Hurted(int power) {};       //虚函数: 自己被别人主动攻击

};

//-------------------具体类: dragon龙类------------------------
class Cdragon : public Canimal
{
public:
  Cdragon(double _value = 100, double _power = 50)
  {
    this->lifeValue = _value;
    this->power = _power;
  }

  //自己被别人攻击
  void Hurted(int power)
  {

    this->lifeValue -= power;
    if (lifeValue <= 0)
    {
      cout << "龙被打死了 ";
      killDragon++;
    }

  }

  //被反击:攻击别人时,被别人反击
  void Fightback(Canimal *p)
  {
    p->Hurted(0.5*power);

  }

  //主动攻击: 自己攻击别人,使别人受伤,自己也受到一些对方的反击伤害
  void Attack(Canimal *other)
  {
    other->Hurted(power);  //攻击别人,使别人受伤
    other->Fightback(this);//被别人反击,自己也受伤
  }

};

//-------------------具体类: CLion 狮子类------------------------

class Clion : public Canimal
{
public:
  Clion(double _value = 100, double _power = 30)
  {
    this->lifeValue = _value;
    this->power = _power;
  }


  //自己被别人攻击
  void Hurted(int power)
  {

    this->lifeValue -= power;
    if (lifeValue <= 0)
    {
      cout << "狮子被打死了 ";
      killLion++;
    }

  }

  //被反击:攻击别人时,被别人反击
  void Fightback(Canimal *p)
  {
    p->Hurted(0.5*power);

  }

  //主动攻击: 自己攻击别人,使别人受伤,自己也受到一些对方的反击伤害
  void Attack(Canimal *other)
  {
    other->Hurted(power);  //攻击别人,使别人受伤
    other->Fightback(this);//被别人反击,自己也受伤

  }

};
//-------------------具体类: CTiger 老虎类------------------------
class Ctiger : public Canimal
{
public:
  Ctiger(double _value = 100, double _power = 20)
  {
    this->lifeValue = _value;
    this->power = _power;
  }


  //自己被别人攻击
  void Hurted(int power)
  {

    this->lifeValue -= power;
    if (lifeValue <= 0)
    {
      cout << "老虎被打死了 ";
      killTiger++;
    }

  }

  //被反击:攻击别人时,被别人反击
  void Fightback(Canimal *p)
  {
    p->Hurted(0.5*power);

  }

  //主动攻击: 自己攻击别人,使别人受伤,自己也受到一些对方的反击伤害
  void Attack(Canimal *other)
  {
    other->Hurted(power);  //攻击别人,使别人受伤
    other->Fightback(this);//被别人反击,自己也受伤
  }

};



//=============================主函数================================
int main()
{

  srand((unsigned)time(NULL));

  //1. 初始化一群动物对象
  Cdragon dragon[MaxDragon];//龙类对象数组
  Clion lion[MaxLion];                //狮子类对象数组
  Ctiger tiger[MaxTiger];            //老虎类对象数组

  //2. 动物开始随机厮杀
  cout << "王者争霸游戏已开启,请按任意键开始>>>>>" << endl;
  getchar();

  for (int i = 0; i < iter; ++i)
  {
    cout << "开始第" << i + 1 << "轮厮杀: ";

    switch (rand() % 2)
    {
    case 0: //龙攻击狮子
    {
      //随机选择一个龙和一头狮子
      int id1 = rand() % MaxDragon;
      int id2 = rand() % MaxLion;

      dragon[id1].Attack(&lion[id2]);
    }

    break;
    case 1: //狮子攻击老虎
    {
      //随机选择一个狮子和一只老虎
      int id1 = rand() % MaxLion;
      int id2 = rand() % MaxTiger;

      lion[id1].Attack(&tiger[id2]);
    }  break;

    case 2: // 老虎攻击龙
    {
      //随机选择一个老虎和一条龙
      int id1 = rand() % MaxTiger;
      int id2 = rand() % MaxDragon;

      tiger[id1].Attack(&dragon[id2]);
    }  break;

    }//switch

    cout << "kill掉" << (killDragon + killLion + killTiger) << "个怪物" << endl;



  }//for


  cout << "-------------------------" << endl;
  cout << "游戏结束!" << endl<<endl;

  cout << "共kill掉" << killDragon << "条龙" << endl;
  cout << "共kill掉" << killLion << "头狮" << endl;
  cout << "共kill掉" << killTiger << "只虎" << endl;


  system("pause");
  return 0;
}

面向对象编程（C++）一码知天下(合集版)

第一章：从面向过程到面向对象的过渡案例

PSO作业参考demo(C++)

PSO.h — 粒子群算法类定义

PSO.cpp — 粒子群算法类实现

main.cpp — PSO主函数

function.h — 测试函数声明

function.cpp — 测试函数实现

Chapt_1_ReadData：C++文件读取演示

c++读取文件.cpp

chapt_1_ScoreSystem：学生成绩管理系统（C语言风格，面向过程）

main.c — 学生成绩管理系统主函数

score.h — 学生管理头文件

score.c — 学生管理函数实现

data.txt — 测试数据

第二章：C++与C（C++新增语法特性）

inlineFunction.cpp — 内联函数

namespace.cpp — 命名空间

new-malloc.cpp — new与malloc对比

referenceDemo1.cpp — 引用基础

referenceDemo2.cpp — 引用深入

try-catch_1.cpp — try-catch原理剖析

try-catch_2.cpp — try-catch课堂演示

constDemo.cpp — const基础

const与指针.cpp — const与指针

defaultArgument_1.cpp — 默认形参（基础）

defaultArgument_2.cpp — 默认形参（深入）

第三章：类与对象（上）

this.cpp / constructor.cpp — 构造函数课堂演示

构造函数的使用(课堂范例).cpp

triangleDemo.cpp — 三角形类的演示

类对象的使用-一码知天下.cpp

classDemo.cpp — 类的综合演示

Distribution of the objects and object members.cpp — 对象分布规律

friend-global function.cpp — 友元全局函数

shallow-deep — 浅拷贝与深拷贝

student.h

student.cpp

main.cpp

shallow-deep-copy — 另一种浅拷贝与深拷贝实现

student.h

student.cpp

main.cpp

第四章：类与对象（下）— static 与 const

const — 常量

const_demo_1(常量const本质剖析).cpp

const_demo_2(常成员变量,常函数,常对象).cpp

static — 静态成员

complex.h

complex.cpp

main.cpp

第五章：类关系—继承

chapt5_class relations/inheritance/README.md

1-inheritance_定义和三种继承理解.cpp

2-inheritance-父子同名与数据访问方式.cpp

3-inheritance-多继承与基类构函调用次序问题.cpp

4-inheritance-菱形继承sofabed.cpp

5-inheritance-赋值兼容.cpp

第六章：多态性

1-静态多态性

complex.h

complex.cpp

main.cpp

2-动态多态性

1-预备工作-赋值兼容性.cpp

2-动态多态性-虚函数-指哪打哪.cpp

3-动态多态性-虚函数原理挖掘.cpp

4-动态多态性-虚析构函数.cpp

5-动态多态性-纯虚函数.cpp

游戏王者争霸-虚函数与动态多态.cpp

参考答案