C/C++ 类与构造析构等知识
简单定义类
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
int uid;
char *name;
int age;
public:
void set(int id, char *name, int age)
{
this->uid = id;
this->name = name;
this->age = age;
}
void display()
{
cout << this->uid << this->name << this->age << endl;
}
};
void Call(const Student &ptr)
{
cout << ptr.name << endl;
}
int main(int argc, char *argv[])
{
Student stu; // 实例化
stu.set(1001, "lyshark", 23); // 设置数据
cout << stu.uid << stu.name << stu.age << endl; // 输出
stu.display(); // 使用成员函数输出
Student *ptr = &stu; // 使用指针
cout << ptr->uid << ptr->name << ptr->age << endl;
Call(stu);
system("pause");
return 0;
}
构造/析构 函数: 构造函数与类名相同，没有返回值，不写void，可以发生重载，可以有参数
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
int uid;
char *name;
int age;
public:
Student(int uid,char *name,int age) // 构造函数
{
this->uid = uid;
this->name = name;
this->age = age;
}
~Student() // 析构函数
{
cout << "执行结束,析构 !" << endl;
}
void Display()
{
cout << this->name << endl;
}
};
int main(int argc, char *argv[])
{
class Student *stu_ptr[3];
Student stu1(1001, "admin", 22);
Student stu2(1002, "guest", 33);
Student stu3(1003, "tudyit", 25);
stu_ptr[0] = &stu1;
stu_ptr[1] = &stu2;
stu_ptr[2] = &stu3;
for (int x = 0; x < 3; x++)
stu_ptr[x]->Display();
system("pause");
return 0;
}
析构函数，没有返回值，不可以写参数，不能发生重载，多用于最后的类的清理左右。
无参数构造函数（默认构造函数），有参数
拷贝构造函数:
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
int uid;
char *name;
int age;
public:
Student(int uid,char *name,int age) // 构造函数
{
this->uid = uid;
this->name = name;
this->age = age;
}
Student(const Student& ptr) // 拷贝构造函数
{
name = ptr.name; // 将 拷贝参数赋值给被拷贝类中
cout << "kaobei" << endl;
}
};
int main(int argc, char *argv[])
{
Student stu1(1001, "admin", 22);
// 拷贝构造函数：括号法调用
// 调用拷贝构造函数 stu1 拷贝到stu2中
Student stu2(stu1);
cout << stu2.name << endl;
Student stu3 = Student(stu1);
cout << stu3.name << endl;
system("pause");
return 0;
}
浅拷被： 容易崩溃，系统简单的传值，出现问题。
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
char * m_name;
int m_age;
public:
Student()
{
}
Student(char * name, int age)
{
m_name = (char *)malloc(strlen(name) + 1);
strcpy(m_name, name);
}
~Student()
{
if (m_name != NULL)
free(m_name);
}
};
int main(int argc, char *argv[])
{
Student stu1("lyshark",25);
// < 浅拷贝,出现了崩溃的问题> 因为执行了两次析构，出现了冲突
Student stu2(stu1); // 调用拷贝构造函数
system("pause");
return 0;
}
深拷贝： 自己开辟堆空间，然后自己在拷贝构造函数中拷贝数据，防止冲突，同样的代码不会出现问题了。
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
char * m_name;
int m_age;
public:
Student()
{
}
Student(char * name, int age)
{
m_name = (char *)malloc(strlen(name) + 1);
strcpy(m_name, name);
}
~Student()
{
if (m_name != NULL)
free(m_name);
}
Student(const Student &ptr)
{
m_age = ptr.m_age;
m_name = (char *)malloc(strlen(ptr.m_name) + 1);
strcpy(m_name, ptr.m_name); // 深层拷贝
}
};
int main(int argc, char *argv[])
{
Student stu1("lyshark",25);
// < 浅拷贝,出现了崩溃的问题> 因为执行了两次析构，出现了冲突
Student stu2(stu1); // 调用拷贝构造函数
system("pause");
return 0;
}
多个对象的构造和析构：初始化列表
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
char * m_name;
int m_age;
public:
Student(char * x, int y) :m_name(x), m_age(y){}
};
int main(int argc, char *argv[])
{
Student stu("lyshark",23);
cout << stu.m_name << stu.m_age << endl;
system("pause");
return 0;
}
explicit 关键字的作用 该关键字为了防止隐世类型转换,就是防止你瞎搞。
#include <iostream>
#include <string>
using namespace std;
class MyString
{
public:
char * m_Str;
public:
MyString(const char *str)
{
}
// 该关键字为了防止隐世类型转换
explicit MyString(int num)
{
}
};
int main(int argc, char *argv[])
{
MyString str = "lyshark"; // 显示调用
// MyString str2 = 10;
system("pause");
return 0;
}
new 动态对象创建: 忘记 malloc() /free 吧，new 可以自动分配初始化空间，非常方便。开辟空间到堆。
#include <iostream>
#include <string>
using namespace std;
class Student
{
public:
char * m_Str;
public:
Student()
{
cout << "默认构造调用" << endl;
}
~Student()
{
cout << "默认析构调用" << endl;
}
};
int main(int argc, char *argv[])
{
// Student stu1; // 在站区开辟空间
// 所有new出来的对象都会返回该类型的指针
// malloc 返回 void* 还必须要强转
// new 会调用构造函数? new 并不是函数而是运算符
Student *stu2 = new Student; // 堆区开辟空间
// 释放堆空间
delete stu2;
// new 来开辟数组 , 他一定会调用默认构造函数，有多少数组成员就调用多少次！
Student *pArray = new Student[10];
pArray[0].m_Str = "lyshark";
cout << pArray[0].m_Str << endl;
// 释放整个数组,必须加[] 中括号
delete [] pArray;
system("pause");
return 0;
}
静态成员变量: static声明就是静态成员变量，无论建立多少对象，都只有一个静态数据的拷贝，所有对象都共享这个静态数据。
#include <iostream>
using namespace std;
class Student
{
public:
// 静态成员变量,在类内声明，在类外初始化
static int m_number; // 定义静态变量
};
int Student::m_number = 100; // 类外初始化实现
int main(int argc, char *argv[])
{
Student stu1, stu2;
stu1.m_number = 200; // stu1赋值后,会影响stu2里面的,两个是共享数据的
cout << stu1.m_number << endl;
cout << stu2.m_number << endl;
cout << "通过类名直接访问:"<< Student::m_number << endl;
system("pause");
return 0;
}
静态成员函数:
#include <iostream>
using namespace std;
class Student
{
public:
static void Display()
{
cout << "hello lyshark" << endl;
}
};
int main(int argc, char *argv[])
{
Student stu1,stu2;
// 静态成员函数,不可以访问普通成员变量
// 但是可以访问静态成员变量
stu1.Display(); // 两个对象同样是调用的一个函数。
stu2.Display();
system("pause");
return 0;
}
单例模式设计思想： 一个类中，是能实例化出一个对象，这样就可以防止冲突的情况发生。
想想，如何实现，不论new多少次，始终只能保证，创建一个对象，不多创建。
#include <iostream>
using namespace std;
// 创建列中的对象，并且保证只有一个对象可以使用，一个对象实例。
class ChairMan
{
private:
// 1.将构造函数自由化，改成private
//
ChairMan(){ cout << "create super" << endl; }
public:
static ChairMan *singleMan;
};
ChairMan * ChairMan::singleMan = new ChairMan;
int main(int argc, char *argv[])
{
cout << "main" << endl; // 主席创建，先于 main
ChairMan::singleMan;
ChairMan *cm1 = ChairMan::singleMan;
system("pause");
return 0;
}
安全的改进
#include <iostream>
using namespace std;
// 创建列中的对象，并且保证只有一个对象可以使用，一个对象实例。
class ChairMan
{
private:
// 1.将构造函数自由化，改成private
//
ChairMan(){ cout << "create super" << endl; }
ChairMan(const ChairMan &ch) {};
private:
static ChairMan *singleMan;
public:
// 通过提供的接口实现访问
static ChairMan* getInstance()
{
return singleMan;
}
};
ChairMan * ChairMan::singleMan = new ChairMan;
int main(int argc, char *argv[])
{
ChairMan * cm1 = ChairMan::getInstance();
ChairMan * cm2 = ChairMan::getInstance();
if (cm1 == cm2)
cout << "相等" << endl;
// 现在其实也能改? 下面可以强改,加上拷贝构造，直接完事。
ChairMan *cm3 = new ChairMan(*cm2);
if (cm2 == cm3)
cout << "不相等" << endl;
system("pause");
return 0;
}
打印机的单例模式案例。
#include <iostream>
#include <string>
using namespace std;
class Printer
{
private:
static Printer * singlePrinter;
private:
Printer(){ };
Printer(const Printer & ptr);
public:
static Printer * getInstance()
{
return singlePrinter;
}
static void PrintText(string text)
{
cout << text << endl;
}
};
Printer * Printer::singlePrinter = new Printer;
int main(int argc, char *argv[])
{
// 拿到打印机对象指针,后期通过该指针操作数据
Printer * ptr = Printer::getInstance();
ptr->PrintText("hello lyshark"); // 调用打印机
system("pause");
return 0;
}
this 指针: this指针指向被调用的成员函数所属的对象，
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
char *name;
int age;
public:
Person(char *p_name, int p_age) { this->name = p_name; this->age = p_age; }
void Compare_Age(Person & ptr) // 对比年龄是否相等
{
if (this->age == ptr.age)
cout << "Same age" << endl; // 年龄相同
else
cout << "Same not age" << endl; // 年龄不同
}
void PlusAge(Person & ptr) // 两个年龄相加
{
this->age += ptr.age;
}
Person & Push_Age(Person &ptr)
{
this->age += ptr.age;
return *this; // 返回指向对象本体
}
};
int main(int argc, char *argv[])
{
Person per1("lyshark", 33);
Person per2("admin", 33);
// ----------------------------------------
per1.Compare_Age(per2); // 判断两个类年龄是否相等
// ----------------------------------------
per1.PlusAge(per2); // 将两个年龄相加
cout << per1.age << endl; // 输出年龄
// ----------------------------------------
per1.Push_Age(per2).Push_Age(per2); // 链式编程(必须传递引用)
cout << per1.age << endl;
system("pause");
return 0;
}
空指针访问成员函数: 如果用不到this则可以调用，用到的话就会报错。
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
int m_age;
public:
void show() { cout << "person show" << endl; }
void show_age()
{
if (this == NULL) // 防止使用空指针访问
return;
cout << "show: "<< m_age << endl;
}
};
int main(int argc, char *argv[])
{
Person *ptr = NULL;
ptr->show(); // 这个可以
ptr->show_age(); // 不可以
// show_age() 默认会加上 this --> 那么如果传递空指针则失败
// 代码接收空指针,会溢出
system("pause");
return 0;
}
常函数、常对象： 使用const 修饰成员函数，则是常函数，
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
int m_x;
int m_y;
public:
Person()
{
this->m_x = 0;
this->m_y = 0;
}
void showInfo() const // 声明常函数,函数内部不可有修改指针的指向
{
// this->m_x = 1000; 相当于修改成了: --> const Person * const this
cout << this->m_x << endl;
cout << this->m_y << endl;
}
};
int main(int argc, char *argv[])
{
Person per1;
per1.showInfo();
// 定义常对象，常对象不允许修改数据。
const Person per2;
system("pause");
return 0;
}
友元函数的定义(全局函数): 将全局函数定义为友元函数，让外部函数，可以访问类内部的私有数据。
#include <iostream>
#include <string>
using namespace std;
class Building
{
friend void goodGay(Building *building);
private:
string m_badRoom; // 私有的卧室
string m_sittingRoom; // 客厅
public:
Building()
{
this->m_sittingRoom = "客厅";
this->m_badRoom = "卧室";
}
};
// 全局函数,我想让他能访问到私有的卧室
void goodGay(Building *building)
{
cout << "访问我的客厅:" << building->m_badRoom << endl;
cout << "访问我的卧室:" << building->m_sittingRoom << endl;
}
int main(int argc, char *argv[])
{
Building *building = new Building;
goodGay(building);
system("pause");
return 0;
}
让整个类做友元类:
#include <iostream>
#include <string>
using namespace std;
class Teacher
{
friend class Student; // 让Student学生,可以访问我的私有成员
private:
char * m_school; // 老师所在的学校
char * m_class; // 老师所教的班级
public:
Teacher()
{
this->m_school = "中心小学";
this->m_class = "一年级二班";
}
};
class Student
{
private:
Teacher *ptr; // 设置一个指向teacher的指针
public:
Student()
{
ptr = new Teacher; // 初始化一下
}
void Display()
{
cout << "学生访问到的学校: " << this->ptr->m_school << endl;
cout << "学生访问到的班级: " << this->ptr->m_class << endl;
}
};
int main(int argc, char *argv[])
{
Student stu;
stu.Display();
system("pause");
return 0;
}
C/C++ 类与构造析构等知识的更多相关文章
- C++ 类、构造析构、深拷贝
1st,感性理解类的思想,就是把数据和对数据的操作打包在一块儿,设计类的时候要 想好数据部分和 要进行的操作.以下是时间类的示意,时间包含时分秒,Time为构造函数,该类支持的操作就是设置时间和读取时 ...
- 转：Delphi2010新发现-类的构造和析构函数功能
Delphi2010发布了. 虽然凭着对Delphi的热爱第一时间就安装了,但是现在可能是年纪大了,对新事物缺乏兴趣了.一直都没有仔细研究. 今天有点时间试了一下新功能. 本来C#和Delphi.NE ...
- Delphi2010新发现-类的构造和析构函数功能
Delphi2010发布了. 虽然凭着对Delphi的热爱第一时间就安装了,但是现在可能是年纪大了,对新事物缺乏兴趣了.一直都没有仔细研究. 今天有点时间试了一下新功能. 本来C#和Delphi.NE ...
- C++面试常见问题——10派生类的构造与析构
派生类的构造与析构 派生类的构造 派生时构造函数与析构函数不会被继承,需要重新定义派生类的构造函数与析构函数.派生类对象包含了基类对象的值,创建派生类时首先会调用基类的构造函数,若派生类中含有其它类对 ...
- C++学习笔记 构造&析构 友元 new&delete
构造&析构函数 构造函数 定义:与类同名,可以有参可以无参,主要功能用于在类的对象创建时定义初始化的状态,无返回值,也不能用void修饰,构造函数不能被直接调用,必须通过new运算符在创建对象 ...
- Effective C++笔记：构造/析构/赋值运算
条款05:了解C++默默编写并调用哪些函数 默认构造函数.拷贝构造函数.拷贝赋值函数.析构函数构成了一个类的脊梁,只有良好的处理这些函数的定义才能保证类的设计良好性. 当我们没有人为的定义上面的几个函 ...
- 从汇编看c++中含有虚基类对象的析构
c++中,当继承结构中含有虚基类时,在构造对象时编译器会通过将一个标志位置1(表示调用虚基类构造函数),或者置0(表示不调用虚基类构造函数)来防止重复构造虚基类子对象.如下图菱形结构所示: 当构造类B ...
- Effective C++ ——构造/析构/赋值运算符
条款五:了解C++默认编写并调用那些函数 是否存在空的类? 假设定义类为class Empty{}:当C++编译器处理过后会变成如下的形式: class Empty{ Empty(){} ~Empty ...
- EffectiveC++ 第2章 构造/析构/赋值运算
我根据自己的理解,对原文的精华部分进行了提炼,并在一些难以理解的地方加上了自己的"可能比较准确"的「翻译」. Chapter 2 构造 / 析构 / 赋值 条款 05:了解C++ ...
- 构造&析构
构造&析构函数 构造函数 定义:与类同名,可以有参可以无参,主要功能用于在类的对象创建时定义初始化的状态,无返回值,也不能用void修饰,构造函数不能被直接调用,必须通过new运算符在创建对象 ...
随机推荐
- sort与uniq
1 sort 将文本文件内容加以排序 语法: sort [-bcdfimMnr][-o<输出文件>][-t<分隔字符>][+<起始栏位>-<结束栏位>] ...
- 🚀Flutter应用程序的加固原理
在移动应用开发中,Flutter已经成为一种非常流行的技术选项,可以同时在Android和iOS平台上构建高性能.高质量的移动应用程序.但是,由于其跨平台特性,Flutter应用程序也面临着一些安 ...
- ES5新增语法
ES5中给我们新增了一些方法,可以很方便的操作数组或者字符串,这些方法主要包括:数组方法.字符串方法.对象方法. 1. 数组方法 迭代(遍历)方法:forEach() .map().filter(). ...
- freeswitch的gateway配置方案优化
概述 freeswitch是一款简单好用的VOIP开源软交换平台. 在之前的文章中,我们简单介绍过gateway的三种配置方案,但是实际应用之后发现,方案中的参数设置有缺陷,会导致一些问题. 本文档中 ...
- python常见面试题讲解（十二）句子逆序
题目描述 将一个英文语句以单词为单位逆序排放.例如"I am a boy",逆序排放后为"boy a am I"所有单词之间用一个空格隔开,语句中除了英文字母外 ...
- asio 使用 openssl 示例
#include <boost/asio.hpp> #include <boost/asio/ssl.hpp> #include <boost/algorithm/str ...
- 如果诸葛亮用C#写出师表...
看到一篇18年的文章 "C++版<出师表>",站长觉得挺有意思的,就用C# 控制台也实现了一遍,技术上没啥难度,但复制代码费了1.2个小时,纯粹无聊写着玩,看者别在意枚 ...
- 使用QQ屏幕识图实现识别表格功能
1.问题 目前市场上的OCR工具对于识别表格功能均是采取了收费制度,但我们时常要进行一些表格的复制(原表格为图片) 便可以使用QQ或钉钉自带的功能来实现 2.解决 1.QQ屏幕识图 先使用屏幕识图功能 ...
- [转帖]TiDB BR 备份至 MinIO S3 实战
https://tidb.net/blog/3a31d41d#3.%E9%83%A8%E7%BD%B2%20MinIO%20S3%20%E5%8F%8A%E5%A4%87%E4%BB%BD%E6%81 ...
- [转帖]CentOS7完美升级gcc版本方法
https://blog.whsir.com/post-4975.html 在某些应用场景中,需要特定的gcc版本支持,但是轻易不要去编译gcc.不要去编译gcc.不要去编译gcc,我这里推荐使用红帽 ...