c++从入门到精通——数组类封装以及操作符重载-天翼云

c++从入门到精通——数组类封装以及操作符重载

2024-10-17 08:21:21 阅读次数：27

#include "myArray.h"

MyArray::MyArray()
{
//  cout << "默认构造函数调用" << endl;
  this->m_Capacity = 100;
  this->m_Size = 0;
  this->pAddress = new int[this->m_Capacity];
}

MyArray::MyArray(int capacity)
{
//  cout << "有参构造函数调用" << endl;
  this->m_Capacity = capacity;
  this->m_Size = 0;
  this->pAddress = new int[this->m_Capacity];
}

MyArray::MyArray(const MyArray & arr)
{
//  cout << "拷贝构造函数调用" << endl;
  this->m_Capacity = arr.m_Capacity;
  this->m_Size = arr.m_Size;
  //this->pAddress = arr.pAddress;

  this->pAddress = new int[arr.m_Capacity];

  for (int i = 0; i < m_Size;i++)
  {
    this->pAddress[i] = arr.pAddress[i];
  }

}

//尾插法
void MyArray::pushBack(int val)
{
  this->pAddress[this->m_Size] = val;
  this->m_Size++;
}

//根据位置设置数据
void MyArray::setData(int pos, int val)
{
  this->pAddress[pos] = val;
}

//根据位置获取数据
int MyArray::getData(int pos)
{
  return this->pAddress[pos];
}

//获取数组容量
int MyArray::getCapcity()
{
  return this->m_Capacity;

}

//获取数组大小
int MyArray::getSize()
{
  return this->m_Size;
}

//析构
MyArray::~MyArray()
{
  if (this->pAddress != NULL)
  {
    cout << "析构函数调用" << endl;
    delete [] this->pAddress;
    this->pAddress = NULL;
  }
}

int& MyArray::operator[](int index)
{

  return this->pAddress[index];
}

mYarray.h

#pragma  once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;


class MyArray
{
public:

  MyArray(); //默认构造 可以给100容量

  MyArray(int capacity); //有参构造

  MyArray(const MyArray & arr); //拷贝构造

  //尾插法
  void pushBack(int val);

  //根据位置设置数据
  void setData(int pos, int val);

  //根据位置获取数据
  int getData(int pos);

  //获取数组容量
  int getCapcity();

  //获取数组大小
  int getSize();

  //析构
  ~MyArray();

  //重载[]运算符
  int& operator[](int index);
  

private:
  int m_Capacity; //数组容量
  int m_Size; //数组大小
  int *pAddress; //真实在堆区开辟的数组的指针
};

myArray.cpp

##include "myArray.h"

MyArray::MyArray()
{
  cout << "默认构造函数调用" << endl;
  this->m_Capacity = 100;
  this->m_Size = 0;
  this->pAddress = new int[this->m_Capacity];
}

MyArray::MyArray(int capacity)
{
  cout << "有参构造函数调用" << endl;
  this->m_Capacity = capacity;
  this->m_Size = 0;
  this->pAddress = new int[this->m_Capacity];
}

MyArray::MyArray(const MyArray & arr)
{
  cout << "拷贝构造函数调用" << endl;
  this->m_Capacity = arr.m_Capacity;
  this->m_Size = arr.m_Size;
  //this->pAddress = arr.pAddress;

  this->pAddress = new int[arr.m_Capacity];

  for (int i = 0; i < m_Size;i++)
  {
    this->pAddress[i] = arr.pAddress[i];
  }

}

//尾插法
void MyArray::pushBack(int val)
{
  this->pAddress[this->m_Size] = val;
  this->m_Size++;
}

//根据位置设置数据
void MyArray::setData(int pos, int val)
{
  this->pAddress[pos] = val;
}

//根据位置获取数据
int MyArray::getData(int pos)
{
  return this->pAddress[pos];
}

//获取数组容量
int MyArray::getCapcity()
{
  return this->m_Capacity;

}

//获取数组大小
int MyArray::getSize()
{
  return this->m_Size;
}

//析构
MyArray::~MyArray()
{
  if (this->pAddress != NULL)
  {
    cout << "析构函数调用" << endl;
    delete [] this->pAddress;
    this->pAddress = NULL;
  }
}

int& MyArray::operator[](int index)
{

  return this->pAddress[index];
}

操作符重载

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Person{
public:
  Person(){};
  Person(int a,int b):m_A(a),m_B(b){};
  int m_A;
  int m_B;
//  Person operator+(Person &p){
//    Person temp;
//    temp.m_A = this->m_A+p.m_A;
//    temp.m_B = this->m_B+p.m_B;
//    return temp;
//  }
};
Person operator+(Person &p1,Person &p2)
{
  Person temp;
  temp.m_A = p1.m_A+p2.m_A;
  temp.m_B = p1.m_B+p2.m_B;
  return temp;
}
Person operator+(Person &p1,int num){
  Person temp;
  temp.m_A = p1.m_A+num;
  temp.m_B = p1.m_B+num;
  return temp;
}
Person operator-(Person &p1,int num){
  Person temp;
  temp.m_A = p1.m_A-num;
  temp.m_B = p1.m_B-num;
  return temp;
}
void test01(){
  Person p1(10, 10);
  Person p2(20, 20);

  Person p3 = p1 + p2;
  //Person p3 = operator+(p1, p2); //全局函数本质

  //Person p3 = p1.operator+(p2); //成员函数本质

  cout << "p3.m_A = " << p3.m_A << " p3.m_B = " << p3.m_B << endl;


  //运算符重载  可不可以发生 函数重载？  可以

  //p1 + 10;
}
int main(){
  test01();
  system("pause");
  return EXIT_SUCCESS;
}

c++从入门到精通——数组类封装以及操作符重载

左移运算符重载

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Person {
  friend ostream& operator<<(ostream &cout,Person &p1);
public:
  Person(int a,int b):m_A(a),m_B(b){};
private:
  int m_A;
  int m_B;
};
ostream& operator<<(ostream &cout,Person &p1){
  cout << "m_A = " << p1.m_A << " m_B = " << p1.m_B;
  return cout;
}
void test01(){
  Person p1(10, 10);
  cout << p1 << endl;
  printf("ok");
}
int main(){
  test01();
  system("pause");
  return EXIT_SUCCESS;
}

c++从入门到精通——数组类封装以及操作符重载

递增运算符重载

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class MyInter
{
  friend ostream& operator<<(ostream& cout, MyInter& myInt);
public:
  MyInter()
  {
    m_Num = 0;
  }

  //前置++ 重载
  MyInter& operator++()
  {
    this->m_Num++;
    return *this;
  }

  //后置++ 重载
  MyInter operator++(int)
  {
    //先记录初始状态
    MyInter temp = *this;

    this->m_Num++;

    return temp;
  }

private:
  int m_Num;
};


ostream& operator<<(ostream& cout , MyInter& myInt)
{
  cout << myInt.m_Num;
  return cout;
}

void test01()
{
  MyInter myInt;
  cout << ++(++myInt) << endl; 
  cout << myInt << endl; 
}

void test02()
{
  MyInter myInt;

  cout << myInt++ << endl;
  cout << myInt << endl;

}

int main(){
  //test01();
  test02();


  //int a = 0;
  //cout << ++(++a) << endl;
  //cout << a << endl;

  //int b = 0;
  //cout << (b++)++ << endl;

  system("pause");
  return EXIT_SUCCESS;
}

指针重载

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:
  Person(int age)
  { 
    cout << "Person的有参构造调用" << endl;
    this->m_Age = age;
  }

  void showAge()
  {
    cout << "年龄为： "<< this->m_Age << endl;
  }

  ~Person()
  {
    cout << "Person的析构调用" << endl;
  }

  int m_Age;
};

class SmartPoint
{
public:
  SmartPoint(Person * person)
  {
    this->m_person = person;
  }

  //重载->运算符
  Person * operator->()
  {
    return this->m_person;
  }
  //重载 * 运算符
  Person& operator*()
  {
    return *m_person;
  }
  ~SmartPoint()
  {
    if (this->m_person)
    {
      delete this->m_person;
      this->m_person = NULL;
    }
  }
private:
  Person * m_person;
};

void test01()
{
  //Person * p = new Person(18);
  //(*p).showAge();
  //p->showAge();
  //delete p;


  //利用智能指针 管理 new出来的person的释放操作
  SmartPoint sp(new Person(18));

  sp->showAge(); // 本质sp->->showAge(); 编译器简化为 sp->showAge();

  (*sp).showAge();

}


int main(){
  test01();

  system("pause");
  return EXIT_SUCCESS;
}

赋值运算符重载

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//编译器 默认给一个类4个函数   默认构造   析构   拷贝构造 （值拷贝）  operator= (值拷贝)
class Person
{
public:
  Person(char * name, int age)
  {
    this->m_Name = new char[strlen(name) + 1];
    strcpy(this->m_Name, name);
    this->m_Age = age;
  }

  //重载 =
  Person& operator=( const Person &p)
  {
    //先判断原来堆区释放有内容，如果有先释放
    if (this->m_Name != NULL)
    {
      delete [] this->m_Name;
      this->m_Name = NULL;
    }

    this->m_Name = new char[strlen(p.m_Name) + 1];
    strcpy(this->m_Name, p.m_Name);
    this->m_Age = p.m_Age;
    return *this;
  }

  //拷贝构造
  Person(const Person & p)
  {
    this->m_Name = new char[strlen(p.m_Name) + 1];
    strcpy(this->m_Name, p.m_Name);
    this->m_Age = p.m_Age;
  }

  ~Person()
  {
    if (this->m_Name!=NULL)
    {
      delete [] this->m_Name;
      this->m_Name = NULL;
    }
  }

  char * m_Name;
  int m_Age;
};


void test01()
{
  Person p1("Tom",10);
  
  Person p2("Jerry",19);
  p2 = p1;

  Person p3("", 0);
  p3 = p2 = p1;


  Person p4 = p3;

  cout << "p1姓名： "<< p1.m_Name << "  p1年龄： " << p1.m_Age << endl;
  cout << "p2姓名： "<< p2.m_Name << "  p2年龄： " << p2.m_Age << endl;
  cout << "p3姓名： " << p3.m_Name << " p3年龄： " << p3.m_Age << endl;

}

int main(){

  test01();

  /*int a = 10;
  int b = 20;
  int c;
  c = a = b;
  cout << "a = " << a << " b = " << b << " c = " << c << endl;*/


  system("pause");
  return EXIT_SUCCESS;
}

活动

智算服务

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

c++从入门到精通——数组类封装以及操作符重载

c++从入门到精通——数组类封装以及操作符重载

mYarray.h

myArray.cpp

操作符重载

左移运算符重载

递增运算符重载

指针重载

赋值运算符重载

相关文章

计算机初级选手的成长历程——操作符详解（2）

Linux+Docer 容器化部署之 Shell 语法入门篇 【Shell基本运算符】

C++：类与对象（2）

【Oracle11g SQL详解】WHERE 子句的条件筛选及常用操作符

C语言中 * 和 ++ 结合的优先级(*++i、*i++) 你还记得吗？（配具体栈内存地址 和 实际测试代码）

【30天玩转python】运算符与表达式

C语言中的数据类型和运算符

shell编程-数组与运算符详解（超详细）

一篇搞定C语言操作符（详解含示例）

【C语言】中的位操作符和移位操作符，原码反码补码以及进制之间的转换

作者介绍

最新文章

【30天玩转python】运算符与表达式

30天拿下Rust之超级好用的“语法糖”

C 语分支初启航，循环开篇韵悠长--逻辑操作符

C 语分支初启航，循环开篇韵悠长--关系，条件操作符

操作符义初解详，运算开篇韵悠长

MYSQL中的增删改查操作（如果想知道MYSQL中有关增删改查操作的知识，那么只看这一篇就足够了！）

热门文章

python-文件的读写操作-入门

C primer plus 学习笔记 第5章 运算符、表达式和语句

操作符

java运算符

js数组的方法和扩展运算符

null undefined NaN的区别和事件

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

java学习第三天笔记-运算符02-数值拆分43

关于逻辑运算符书写效率问题 和数组 处理问题

关于分支与循环的一些细节

C 语分支初启航，循环开篇韵悠长--逻辑操作符

shell 替换运算符

python-运算符-比较运算符

Linux+Docer 容器化部署之 Shell 语法入门篇【Shell基本运算符】

C语言中 * 和 ++ 结合的优先级(++i、i++) 你还记得吗？（配具体栈内存地址和实际测试代码）

C primer plus 学习笔记第5章运算符、表达式和语句

关于逻辑运算符书写效率问题和数组处理问题