小型教育网站的开发与建设论文,中国深圳航空公司官方网站,上传设计作品集的网站,官方网站开发商#x1f307;个人主页#xff1a;平凡的小苏 #x1f4da;学习格言#xff1a;命运给你一个低的起点#xff0c;是想看你精彩的翻盘#xff0c;而不是让你自甘堕落#xff0c;脚下的路虽然难走#xff0c;但我还能走#xff0c;比起向阳而生#xff0c;我更想尝试逆风… 个人主页平凡的小苏 学习格言命运给你一个低的起点是想看你精彩的翻盘而不是让你自甘堕落脚下的路虽然难走但我还能走比起向阳而生我更想尝试逆风翻盘。 C专栏C内功修炼基地 家人们更新不易你们的点赞和⭐关注⭐真的对我真重要各位路 过的友友麻烦多多点赞关注。 欢迎你们的私信提问感谢你们的转发 关注我关注我关注我你们将会看到更多的优质内容 一、设计一个类不能拷贝
1、c98
class CopyBan
{
private:CopyBan(const CopyBan cb);CopyBan operator(const CopyBan cb);
};
int main()
{return 0;
}1、将拷贝构造和赋值运算符重载设置为私有
2、仅仅私有还不够这并不能防止类内部就行拷贝。还要对拷贝构造和赋值运算符重载只声明却不实现。
2、C11
class CopyBan
{CopyBan(const CopyBan cb) delete;CopyBan operator(const CopyBan cb) delete;
}; C11直接使用delete禁用拷贝构造和赋值运算符重载。
二、请设计一个类只能在堆上创建对象
1、将构造设置为私有 将类的构造函数私有拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。 提供一个静态的成员函数在该静态成员函数中完成堆对象的创建 外部通过CreateObj函数构造一个对象后外部可以利用这个对象的指针拷贝构造一个栈区的对象需要禁用拷贝构造。
class HeapOnly
{
public:static HeapOnly* CreateObject(){return new HeapOnly;}
private:HeapOnly() {}// C98// 1.只声明,不实现。因为实现可能会很麻烦而你本身不需要// 2.声明成私有HeapOnly(const HeapOnly);// or// C11 HeapOnly(const HeapOnly) delete;
};2、将析构设置为私有 将析构函数设置为私有栈区对象由于无法析构所以无法创建。堆区对象需要手动调用自己写的清理函数释放。
三、设计一个类只能在栈区设置对象 1、将构造函数私有
2、提供一个静态的CreateObj方法用于构造栈区对象
3、但是无法防止外部构造静态对象。
4、如果想彻底禁止生成静态的对象需要再禁用拷贝构造。不过这样这个类只能生成临时对象或者引用的对象了不能修改。
四、请设计一个类不能被继承
1、C98方式
// C98中构造函数私有化派生类中调不到基类的构造函数。则无法继承
class NonInherit
{public:static NonInherit GetInstance(){return NonInherit();}private:NonInherit(){}
};2、C11方式
final关键字final修饰类表示该类不能被继承。
class A final
{// ....
};五、请设计一个类只能创建一个对象(单例模式)
一个类只能创建一个对象即单例模式该模式可以保证系统中该类只有一个实例并提供一个访问它的全局访问点该实例被所有程序模块共享。
1、饿汉模式设计单例对象
class SingLeton
{
public:static SingLeton* getInstance(){return m_instance;}
private://将构造函数私有SingLeton();//C98方式防拷贝赋值SingLeton(const SingLeton sl);SingLeton operator(const SingLeton sl);//C11方式防拷贝赋值SingLeton(const SingLeton sl) delete;SingLeton operator(const SingLeton sl) delete;static SingLeton m_instance;// 在程序入口之前就完成单例对象的初始化
};SingLeton SingLeton::m_instance;饿汉模式在main函数被加载之前就创建好对象。全局和静态将在main函数之前被加载
1、私有构造函数禁用拷贝构造和赋值运算符重载
2、在类中声明、外部定义一个静态的对象用于调用类中私有的构造函数同时作为单例对象被使用
3、在类中提供一个获取静态对象的函数GetInstance为了外部可调用所以将该函数设置为静态。 饿汉模式的特点 1、单例对象初始化时数据太多会导致启动慢 2、如果多个单例类有初始化的依赖关系饿汉模式无法控制。例如A和B都是单例类因为B的启动依赖A所以需要先初始化A再初始化B但是饿汉模式无法控制对象的初始化顺序。 3、饿汉模式创建的对象绝对不会有线程安全问题因为该模式的对象在main函数之前已经被创建好了main函数之前线程都没启动呢 2、懒汉模式设计单例对象
如果单例对象构造十分耗时或者占用很多资源比如加载插件啊 初始化网络连接啊读取文件啊等等而有可能该对象程序运行时不会用到那么也要在程序一开始就进行初始化就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式延迟加载更好。
2.1、懒汉模式的设计以及线程安全问题
#include iostream
#include thread
#include mutex
#include vector
#include string
#include ctimeusing namespace std;
class SingLeton
{
public:static SingLeton* getInstance(){//双检查加锁if (m_instance nullptr){_mtx.lock();if (m_instance nullptr){m_instance new SingLeton();}_mtx.unlock();}return m_instance;}// 一般全局都要使用单例对象所以单例对象一般不需要显示释放// 有些特殊场景想显示释放一下static void DelInstance(){_mtx.lock();if (m_instance){delete m_instance;m_instance nullptr;}_mtx.unlock();}void Add(const string str){_mtx.lock();_v.push_back(str);_mtx.unlock();}void Print(){_mtx.lock();for (auto e : _v){cout e endl;}cout endl;_mtx.unlock();}// 单例对象回收class GC{public:~GC(){DelInstance();}};static GC _gc;
private://将构造函数私有SingLeton(){}//C11方式防拷贝赋值SingLeton(const SingLeton sl);SingLeton operator(const SingLeton sl);
private:static SingLeton* m_instance;// 在程序入口之前就完成单例对象的初始化static mutex _mtx;//静态锁全局都能看到vectorstring_v;
};
//静态变量初始化
SingLeton* SingLeton::m_instance nullptr;
mutex SingLeton::_mtx;
SingLeton::GC SingLeton::_gc;int main()
{srand(time(0));size_t n 30;thread t1([n]() {for (size_t i 0; i n; i){SingLeton::getInstance()-Add(t1线程: to_string(rand()));}});thread t2([n]() {for (size_t i 0; i n; i){SingLeton::getInstance()-Add(t2线程: to_string(rand()));}});t1.join();t2.join();SingLeton::getInstance()-Print();return 0;
}懒汉模式的特点 1、对象在main函数之后才会创建 2、可以主动控制对象的创建时机。 3、创建对象时存在线程安全问题如果多个线程同时获取单例对象会可能new多个对象最后一个创建的对象指针会覆盖之前创建的对象指针导致内存泄露。 2.2、懒汉模式需要加锁解决的线程安全问题 3、单例对象的释放问题
1、一般单例对象不需要考虑释放资源会在进程结束时自动释放
2、释放的写法如下可以手动清理将一些资源保存可手动调用DelInstance进行资源的回收main函数结束时操作系统也会自动回收单例对象的资源。 4、比较简洁的懒汉模式
class SingLeton
{
public:static SingLeton* getInstance(){m_instance new SingLeton();return m_instance;}
private://将构造函数私有SingLeton(){}//C11方式防拷贝赋值SingLeton(const SingLeton sl);SingLeton operator(const SingLeton sl);
private:static SingLeton* m_instance;// 在程序入口之前就完成单例对象的初始化vectorstring_v;
};
//静态变量初始化
SingLeton* SingLeton::m_instance nullptr;1、私有构造函数禁用拷贝构造和赋值运算符重载
2、通过getInstance返回静态对象静态局部变量是在main函数之后才创建初始化 这种方式构建的单例懒汉模式在C11发布之前会有线程安全问题多线程环境下可能会造成静态对象被初始化多次而C11规定静态局部变量是线程安全的可以放心使用。 六、类型转换
1、C语言中的类型转换
C语言中总共有两种形式的类型转换隐式类型转换和显式类型转换。 隐式类型转化编译器在编译阶段自动进行能转就转不能转就编译失败 显式类型转化需要用户自己处理
void Test ()
{int i 1;// 隐式类型转换double d i;printf(%d, %.2f\n , i, d);int* p i;// 显示的强制类型转换int address (int) p;printf(%x, %d\n , p, address);
}缺陷 转换的可视性比较差所有的转换形式都是以一种相同形式书写难以跟踪错误的转换 2、C中的类型转换
C尤其认为隐式类型转化有些情况下可能会出问题比如数据精度丢失。
2.1、static_cast
int main()
{double d 12.34;int a static_castint(d);cout a endl;return 0;
}static_cast适用于相似类型的转换。可以隐式类型转换的都能用static_cast 2.2、reinterpret_cast
int main()
{double d 12.34;int a static_castint(d);cout a endl;// 这里使用static_cast会报错应该使用reinterpret_cast//int *p static_castint*(a);int* p reinterpret_castint*(a);return 0;
}reinterpret_cast适用于不相关类型之间的转换。不能隐式类型转换只能强制类型转换的用reinterpret_cast 2.3、const_cast
int main()
{const int a 2;int* p const_castint*(a);*p 3;cout a endl;cout *p endl;return 0;
}const_cast用于删除变量的const属性。需要关注内存可见性问题 编译器对const变量会有优化认为const变量不会被改变编译器在优化代码时可能会将变量放到寄存器或者其他高速缓存中。可以在a初始化时加上volatile关键字加了volatile关键字后对变量的读取和写入操作会从内存中进行而不是从缓存中进行。
2.4、dynamic_cast
dynamic_cast用于将一个父类对象的指针 / 引用转换为子类对象的指针或引用(动态转换) 向上转型子类对象指针 / 引用-父类指针 / 引用(不需要转换赋值兼容规则) 向下转型父类对象指针 / 引用-子类指针 / 引用(用dynamic_cast转型是安全的) 注意
1.dynamic_cast只能用于父类含有虚函数的类
2. dynamic_cast会先检查是否能转换成功能成功则转换不能则返回0 3、RTTI
RTTIRun-time Type identifification的简称即运行时类型识别。
C通过以下方式来支持RTTI
1. typeid运算符
2. dynamic_cast运算符
3. decltype七、IO流
1、C语言的输入输出
对输入输出缓冲区的理解
1.可以屏蔽掉低级I/O的实现低级I/O的实现依赖操作系统本身内核的实现所以如果能够屏蔽这部分的差异可以很容易写出可移植的程序。
2.可以使用这部分的内容实现“行”读取的行为对于计算机而言是没有“行”这个概念有了这部分就可以定义“行”的概念然后解析缓冲区的内容返回一个“行”。
2、CIO流
C系统实现了一个庞大的类库其中ios为基类其他类都是直接或间接派生自ios类 IO流的特点 1.面向对象 2.更好支持自定义类对象的IO 3、流提取
流提取是一个阻塞操作以空格或者换行作为一段读取的结束 cinstr是std::string的operator所支持的它的返回值是istream。 为什么返回值istream可以作为while循环的逻辑判断呢这是因为ios这个父类重载了operator bool让其支持了逻辑判断。 从C11开始可以使用explicit关键字来显式声明operator bool()函数完成istream到bool类型的转变以避免隐式类型转换带来的问题。这意味着其内部显式地将istream对象转换为bool类型的值而不能进行隐式类型转换。可以避免编译器自作主张进行隐式类型转换例如编译器将一个对象错误地转换为bool类型的值而导致程序出现错误。
那么问题来了为什么void*和bool可以被重载其实不是他俩能被重载而是自定义类型可以通过类内重载指定类型完成隐式类型转换。本质上是隐式类型转换悄悄的改变类型上面说了你重载了类型之后永远猜不到它会在哪个不该转换的地方发生转换 4、C文件IO流
C根据文件内容的数据格式分为二进制文件和文本文件。采用文件流对象操作文件的一般步骤
1. 定义一个文件流对象 ifstream(只输入用) ofstream(只输出用) fstream(又输出用) 2. 使用文件流对象的成员函数打开一个磁盘文件使得文件流对象和磁盘文件之间建立联系
3. 使用提取和插入运算符对文件进行读写操作或使用成员函数进行读写
4. 关闭文件
4.1、二进制读写
struct ServerInfo
{char _address[32];//不要使用stringint _port;
};struct ConfigManager
{ConfigManager(const char* filename):_filename(filename){}void WriteBin(const ServerInfo info){ofstream ofs(_filename, ofstream::out | ofstream::binary);ofs.write((char*)info, sizeof(info));}void ReadBin(ServerInfo info){ifstream ifs(_filename, ifstream::in | ifstream::binary);ifs.read((char*)info, sizeof(info));}private:string _filename;
};
int main()
{ServerInfo winfo { 192.0.0.1xxxxxxxxxxxxxxxxxxxxx, 80 };string str;cin str;if (str 二进制写){ConfigManager cm(test.txt);cm.WriteBin(winfo);}else if (str 二进制读){ServerInfo rinfo;ConfigManager cm(test.txt);cm.ReadBin(rinfo);cout rinfo._address endl;cout rinfo._port endl;}return 0;
} 二进制读写不要对string对象进行读写操作。 4.2、文本读写简单写法
#include iostream
#include fstream
#include string
using namespace std;class Date
{friend ostream operator (ostream out, const Date d);friend istream operator (istream in, Date d);
public:Date(int year 1, int month 1, int day 1):_year(year), _month(month), _day(day){}operator bool(){// 这里是随意写的假设输入_year为0则结束if (_year 0)return false;elsereturn true;}
private:int _year;int _month;int _day;
};istream operator (istream in, Date d)
{in d._year d._month d._day;return in;
}
ostream operator (ostream out, const Date d)
{out d._year d._month d._day;return out;
}
struct ServerInfo
{char _address[32];//不要使用stringint _port;Date _date;
};
struct ConfigManager
{ConfigManager(const char* filename):_filename(filename){}// 文本读写 C文本读写更简单// 文本读写本质内存中任何类型都是转成字符串在写// c语言文本读写很不方便因为要不断转字符串// c封装了以后就有很大的优势void WriteText(const ServerInfo info){ofstream ofs(_filename, ofstream::out);ofs info._address ;ofs info._port ;ofs info._date endl;}void ReadText(ServerInfo info){ifstream ifs(_filename, ifstream::in);ifs info._address;ifs info._port;ifs info._date;}
private:string _filename;
};
int main()
{ServerInfo winfo { 192.0.0.1xxxxxxxxxxxxxxxxxxxxx, 80,{2023,11,5} };string str;cin str;if (str 文本写){ConfigManager cm(test.txt);cm.WriteText(winfo);}else if (str 文本读){ServerInfo rinfo;ConfigManager cm(test.txt);cm.ReadText(rinfo);cout rinfo._address endl;cout rinfo._port endl;cout rinfo._date endl;}return 0;
}1、使用ofstream进行写入的时候每一个变量写完必须给空格或换行标定每个变量的读取结束否则读取时会读取出错。
2、自定义类型也可以使用流插入和流提取的写法是因为ofstream和ifstream是ostream的子类
子类对象可以调用继承于父类的流插入和流提取。前提是自定义类型重载了流插入和流提取
5、使用stringstream序列化和反序列化
#include iostream
#include fstream
#include string
#include sstream
using namespace std;class Date
{friend ostream operator (ostream out, const Date d);friend istream operator (istream in, Date d);
public:Date(int year 1, int month 1, int day 1):_year(year), _month(month), _day(day){}operator bool(){// 这里是随意写的假设输入_year为0则结束if (_year 0)return false;elsereturn true;}
private:int _year;int _month;int _day;
};istream operator (istream in, Date d)
{in d._year d._month d._day;return in;
}
ostream operator (ostream out, const Date d)
{out d._year d._month d._day;return out;
}
// 序列化和反序列化
struct ChatInfo
{string _name; // 名字int _id; // idDate _date; // 时间string _msg; // 聊天信息
};int main()
{ChatInfo winfo { 张三, 135246, { 2022, 4, 10 }, 晚上一起看电影吧 };stringstream oss;oss winfo._name ;oss winfo._id ;oss winfo._date ;oss winfo._msg;string str oss.str();cout str endl;stringstream iss(str);ChatInfo rinfo;iss rinfo._name;iss rinfo._id;iss rinfo._date;iss rinfo._msg;cout ------------------------------------------------------- endl;cout 姓名 rinfo._name ( rinfo._id ) ;cout rinfo._date endl;cout rinfo._name : rinfo._msg endl;cout ------------------------------------------------------- endl;return 0;
}stringstream兼具ostringstream和istringstream
