《C++ Primer Plus》第十二章复习题和编程练习

目录

  • 一、复习题
  • 二、编程练习

一、复习题

1. 假设String类有如下私有成员：

// String 类声明
class String
{
private: char* str;int len;// ...
};

a. 下述默认构造函数有什么问题？

String::String() { }  // 默认构造函数

b. 下述构造函数有什么问题？

String::String(const char* s)  // 构造函数
{str = s;len = strlen;
}

c. 下述构造函数有什么问题？

String::String(const char* s)  // 构造函数
{strcpy(str, s);len = strlen(s);
}

答：注意：下面的代码需要包含相应的头文件和using声明。
a. 该默认函数并未进行任何操作，则成员变量str与len的值是未知的（和创建局部变量未初始化一个道理）。而String类涉及动态内存分配，所以需要给str适当初始化（一般初始化为空指针——nullptr）。
修改如下：

String::String()  // 默认构造函数
{str = nullptr;len = 0
}

b. 该构造函数中语句str = s; 只是单纯地让str和s指向同一个字符串，str只是存储了s指向的字符串的首地址，这是浅拷贝。而我们需要拷贝存储字符串的副本（深拷贝）。
修改如下：

String::String(const char* s)
{len = strlen(s);  // 存储字符串的长度，不包括空字符str = new char[len + 1];  // 申请空间，别忘了空字符'\0'strcpy(str, s);  // 拷贝字符串内容副本
}

c. 还未在堆上申请空间，str指向的地方是未知的，直接使用函数strcpy()进行内容拷贝会导致不确定的问题。
修改如下：

String::String(const char* s)
{len = strlen(s);  // 存储字符串的长度，不包括空字符str = new char[len + 1];  // 申请空间，别忘了空字符'\0'strcpy(str, s);  // 拷贝字符串内容副本
}

2. 如果你定义了一个类，其指针成员是使用new初始化的，请指出可能出现的三个问题及如何纠正这些问题？

答：
1）问题：没有定义对应的析构函数，和使用对应的delete运算符的形式。
纠正：使用new为成员指针分配空间需要对应的析构函数来释放空间，使用什么形式申请空间就需要使用什么形式释放空间，如：int * pi = new int; —— delete pi; ，int* pa = new int[5];——delete[5]pa;。而且所有构造函数只能使用上面相同的一种new形式，使之与析构函数中的delete形式对应。
2）问题：没有定义相关的复制构造函数。
纠正：如果没有定义赋值构造函数，编译器会提供默认的复制构造函数，其只能进行浅拷贝，只能复制需要拷贝的内容的地址。需要定义相关的复制构造函数进行深拷贝，为拷贝内容申请空间。
3）问题：没有重载对应的赋值运算符
纠正：和问题2一样，如果没有重载赋值运算符，编译器也会提供默认的，同样是浅拷贝。我们需要定义相关的赋值运算符，来进行深度拷贝。需要先释放前面存储的动态空间，然后根据拷贝大小申请新的空间。

3. 如果没有显示提供类方法，编译器将自动生成哪些类方法？请描述这些隐式生成的函数的行为。

答：
1）若没有提供构造函数，则编译器会提供一个默认构造函数，该函数什么都不做，但允许声明数组和未初始化的对象。
2）若没有提供析构函数，则编译器会提供一个默认析构函数，该函数什么都不做。
3）若没有提供拷贝构造函数，则编译器会提供一个默认的拷贝构造函数，该函数进行浅拷贝。
4）若没有提供赋值运算符重载，则编译器会提供默认的赋值运算符重载，该函数也进行浅拷贝。
5）若没有提供地址运算符重载，则编译器会提供默认的地址运算符重载，该函数返回调用对象的地址，也就是this指针的值。

4. 找出并改正下述类声明中的错误。

// nifty 类声明
class nifty
{// 数据char personality[];int talents;// 方法nifty();nifty(char* s);ostream& operator<<(ostream& os, nifty& n);
};nifty::nifty()
{personality = NULL;talents = 0;
}nifty::nifty(char* s)
{personality = new char[strlen(s)];personality = s;talents = 0;
}ostream& nifty::operator<<(ostream& os, nifty& n)
{os << n;
}

答：首先，类声明中一般成员变量为私有成员（private），而成员函数为公有成员（public）。不显式声明时，类（class）默认为private，而结构（struct）默认为public。所以需要将成员函数声明为public。在默认构造函数中，personality是数组名也是指向第一个元素的char指针，但是其指向不能改变，可以使用strcpy()函数将其初始化为空字符串，参数s最好声明为const。在第二个提供一个参数的构造函数中，也是同样的问题。最后一个重载运算符（<<）函数需要被声明为友元函数，且该函数定义完全就是狗屁，我们都还没定义，你就用上了成品。根据上述问题，我们通过把变量personality修改为char指针，然后添加析构函数进行重写代码。（当然拷贝构造函数和赋值运算符重载也是需要的，读者可以自行编写）

下面是正确的代码：

// nifty 类声明
class nifty
{
private:// 数据char* personality;int talents;
public:// 方法nifty();nifty(const char* s);~nifty();friend ostream& operator<<(ostream& os, const nifty& n);
};// 类方法定义
nifty::nifty()  // 默认构造函数
{personality = nullptr;talents = 0;
}nifty::nifty(const char* s)  // 构造函数
{int len = strlen(s);personality = new char[len+1];strcpy(personality, s);talents = 0;
}nifty::~nifty()  // 析构函数
{if (personality != nullptr)delete[]personality;
}ostream& operator<<(ostream& os, const nifty& n)  // 运算符（<<）重载
{os << "Personality: " << personality << endl;os << "Talents: " << talents << endl;return os;
}

5. 对于下面的类声明，回答下面的问题。

// Golfer 类声明
class Golfer
{
private:char* fullname;  // 指向包含高尔夫的名称的字符串int games;  // 保存玩的高尔夫游戏的个数int* scores;  // 指向高尔夫分数数组的第一个元素
public:Golfer();Golfer(const char* name, int g = 0);Golfer(const Golfer& g);~Golfer();
};

a. 下列各条语句将调用哪些类方法？
1 Golfer nancy;
2 Golfer lulu(“Little Lulu”);
3 Golfer roy(“Roy Hobbs”, 12);
4 Golfer *par = new Golfer;
5 Golfer next = lulu;
6 Golfer hazzard = “Weed Thwacker”;
7 *par = nancy;
8 nancy = “Nancy Putter”;
b. 很明显，类需要有另外几个方法才能更有用，但是类需要哪些方法才能防止数据被损坏呢？

答：
a.

  1. 调用默认构造函数。
  2. 调用一个参数的构造函数。
  3. 调用两个参数的构造函数。
  4. 调用默认构造函数。
  5. 调用编译器提供的默认的复制构造函数。
  6. 先调用一个参数的构造函数创建临时对象，然后调用编译器提供的默认复制构造函数。
  7. 调用编译器提供的默认的赋值运算符重载函数。
  8. 先调用一个参数的构造函数创建临时对象，然后调用编译器提供的默认的赋值运算符重载函数。

b. 由于编译器提供的默认的复制构造函数和赋值运算符重载函数都是浅拷贝，所以需要用户自己定义复制构造函数和赋值运算符重载函数来对对象实行深度拷贝，避免程序出现问题。

二、编程练习

1. 对于下面的类声明，为这个类提供实现，并编写一个使用所有成员函数的小程序。

// Cow 类声明
class Cow
{
private:char name[20];char* hobby;double weight;
public:Cow();  // 默认构造函数Cow(const char* nm, const char* ho, double wt);Cow(const Cow& c);  // 复制构造函数~Cow();  // 析构函数Cow& operator=(const Cow& c);  // 赋值运算符重载void ShowCow() const;  // 显示所有有关于奶牛的数据
};

答：三个文件。

Cow.h头文件

#pragma once// 头文件
#include <iostream>// Cow 类声明
class Cow
{
private:char name[20];char* hobby;double weight;
public:Cow();  // 默认构造函数Cow(const char* nm, const char* ho, double wt);Cow(const Cow& c);  // 复制构造函数~Cow();  // 析构函数Cow& operator=(const Cow& c);  // 赋值运算符重载void ShowCow() const;  // 显示所有有关于奶牛的数据
};

main.cpp测试文件

// 头文件
#include "Cow.h"// using 声明
using std::cout;
using std::endl;int main()
{// 默认构造函数Cow cow1;cow1.ShowCow();cout << endl;// 三个参数的构造函数Cow cow2("若雪", "干饭", 888.8);cow2.ShowCow();cout << endl;// 复制构造函数Cow cow3(cow2);cow3.ShowCow();cout << endl;// 赋值运算符cow3 = cow1;cow3.ShowCow();cout << endl;return 0;
}

Cow.cpp方法定义文件

// 头文件
#include "Cow.h"
#include <cstring>// using 声明
using std::cout;
using std::endl;Cow::Cow()  // 默认构造函数
{strcpy(name, "小雪");// 申请空间hobby = new char[strlen("吃草") + 1];strcpy(hobby, "吃草");weight = 888.0;
}Cow::Cow(const char* nm, const char* ho, double wt)
{strcpy(name, nm);// 申请空间hobby = new char[strlen(ho) + 1];strcpy(hobby, ho);weight = wt;
}Cow::Cow(const Cow& c)  // 复制构造函数
{strcpy(name, c.name);// 申请空间hobby = new char[strlen(c.hobby) + 1];strcpy(hobby, c.hobby);weight = c.weight;
}Cow::~Cow()  // 析构函数
{// 释放空间delete[]hobby;  // 与申请的格式对应
}Cow& Cow::operator=(const Cow& c)  // 赋值运算符重载
{if (this == &c)  // 检查是否给自己赋值{return *this;}else{strcpy(name, c.name);// 释放原来的空间delete[]hobby;// 申请新的空间hobby = new char[strlen(c.hobby) + 1];strcpy(hobby, c.hobby);weight = c.weight;return *this;}
}void Cow::ShowCow() const  // 显示所有有关于奶牛的数据
{cout << "Name: " << name << endl;cout << "Hobby: " << hobby << endl;cout << "Weight: " << weight << endl;
}

2. 通过完成下面的工作来改进String类的声明（即将String1.h升级为String2.h）。
a. 对+运算符进行重载，使之可以将两个字符串合并成一个。
b. 提供一个Stringlow()成员函数，将字符串中所有的字母字符转换为小写（注意cctype系列的字符函数）
c. 提供String()成员函数，将字符串中所有字母字符转换为大写。
d. 提供一个这样的成员函数，它接受一个char参数，返回该字符在字符串中出现的次数。使用下面的程序来测试你的工作。

// 头文件
#include "String2.h"// using 声明
using std::cin;
using std::cout;
using std::endl;int main()
{String s1(" and I am a C++ student.");String s2 = "Please enter your name: ";String s3;cout << s2;cin >> s3;s2 = "My name is " + s3;cout << s2 << endl;s2 = s2 + s1;s2.Stringupper();cout << "The string\n" << s2 << "\ncontains " << s2.ch_times('A')<< " 'A' characters in it.\n";s1 = "red";String rgb[3] = { String(s1), String("green"), String("blue") };cout << "Enter the name of a primary color for mixing light: ";String ans;bool success = false;while (cin >> ans){ans.Stringlow();for (int i = 0; i < 3; ++i){if (ans == rgb[i]){cout << "That's right!\n";success = true;break;}}if (success)break;elsecout << "Try again!\n";}cout << "Bye\n";return 0;
}

输出应于下面相似。
Please enter your name: Fretta Farbo
My name is Fretta Farbo.
The string
My NAME IS FRETTA FARBO AND I AM A C++ STUDENT.
contains 6 ‘A’ characters in it.
Enter the name of a primary color for misxing light: yellow
Try again!
BLUE
That’s right!
Bye

答：两个文件。

String2.h头文件

#pragma once// 头文件
#include <iostream>// String 类声明
class String
{
private:char* str;  int len;  // 字符串长度static int num_strings;  // 目前有多少个String对象static const int CINLIM = 80;  // 输入的限制
public:String();  // 默认构造函数String(const char* s);String(const String& s);  // 复制构造函数~String();  // 析构函数int lenth() const { return len; }  // 返回字符串长度int ch_times(char key) const;  // 返回字符key在字符串中出现的次数void Stringlow();void Stringupper();String& operator=(const char* s);String& operator=(const String& s);char& operator[](int i);const char& operator[](int i) const;String operator+(const String& s) const;// 关系运算符重载friend bool operator<(const String& s1, const String& s2);friend bool operator>(const String& s1, const String& s2);friend bool operator==(const String& s1, const String& s2);friend String operator+(const char* s, const String& str);friend std::ostream& operator<<(std::ostream& os, const String& s);friend std::istream& operator>>(std::istream& is, String& s);// 静态成员函数static int HowMany();
};

String2.cpp方法定义文件

// 头文件
#include "String2.h"
#include <cctype>
#include <cstring>// using 声明
using std::endl;// 静态成员变量初始化
int String::num_strings = 0;String::String()  // 默认构造函数
{str = nullptr;len = 0;++num_strings;
}String::String(const char* s)
{len = strlen(s);// 申请空间str = new char[len + 1];strcpy(str, s);++num_strings;
}String::String(const String& s)  // 复制构造函数
{len = s.len;// 申请空间str = new char[len + 1];strcpy(str, s.str);++num_strings;}String::~String()  // 析构函数
{// 释放空间if (str != nullptr)delete[]str;
}int String::ch_times(char key) const  // 返回字符key在字符串中出现的次数
{int times = 0;for (int i = 0; i < len; ++i){if (str[i] == key)++times;}return times;
}void String::Stringlow()
{for (int i = 0; i < len; ++i){str[i] = tolower(str[i]);}
}void String::Stringupper()
{for (int i = 0; i < len; ++i){str[i] = toupper(str[i]);}
}String& String::operator=(const char* s)
{len = strlen(s);// 释放之前的空间delete[]str;// 申请新的空间str = new char[len + 1];strcpy(str, s);return *this;
}String& String::operator=(const String& s)
{len = s.len;// 释放之前的空间delete[]str;// 申请新的空间str = new char[len + 1];strcpy(str, s.str);return *this;
}char& String::operator[](int i)
{return str[i];
}const char& String::operator[](int i) const
{return str[i];
}String String::operator+(const String& s) const
{int total = len + s.len;// 申请空间char* result = new char[total + 1];strcpy(result, str);strcat(result, s.str);String tmp(result);// 释放空间delete[]result;return tmp;
}String operator+(const char* s, const String& str)
{int total = strlen(s) + str.len;// 申请空间char* result = new char[total + 1];strcpy(result, s);strcat(result, str.str);String tmp(result);// 释放空间delete[]result;return tmp;
}// 关系运算符重载
bool operator<(const String& s1, const String& s2)
{return (strcmp(s1.str, s2.str) < 0);
}bool operator>(const String& s1, const String& s2)
{return s2 < s1;
}bool operator==(const String& s1, const String& s2)
{return !strcmp(s1.str, s2.str);
}std::ostream& operator<<(std::ostream& os, const String& s)
{if (s.str != nullptr){os << s.str;}return os;
}std::istream& operator>>(std::istream& is, String& s)
{char tmp[String::CINLIM];is.getline(tmp, String::CINLIM);if (!is){is.clear();while (is.get() != '\n')continue;return is;}s = tmp;return is;
}// 静态成员函数
int String::HowMany()
{return num_strings;
}

运行结果
在这里插入图片描述

3. 重写程序清单10.7和程序清单10.8描述的Stock类，使之使用动态分配的内存，而不是string类对象来存储股票名称。另外，使用重载的operator<<()定义代替show()成员函数。再使用程序清单10.9测试新的程序。

答：使用动态内存分配，可以使用char*指针，也可以使用指向string类的指针。在构造函数中申请空间，在析构函数中释放空间，申请和释放的形式需要匹配。

Stock.h头文件

#pragma once// 头文件
#include <iostream>// Stock 类声明
class Stock
{
private:char* company;  // 股票公司名称int shares;  // 股票数量double share_val;  // 每份股票double total_val;  // 总值void set_tot() { total_val = share_val * shares; }  // 设置总值
public:Stock();  // 默认构造函数Stock(const char* co, int n, double pr);~Stock();  // 析构函数void buy(int num, double pr);  // 买进void sell(int num, double pr);  // 卖出void update(double pr);  // 更新价格// 运算符（<<）重载friend std::ostream& operator<<(std::ostream& os, const Stock& s);const Stock& topval(const Stock& s) const;  // 返回总值大的对象
};

main3.cpp测试文件

// 头文件
#include "Stock.h"// using 声明
using std::cin;
using std::cout;
using std::endl;// 符号常量声明
const int STKS = 4;int main()
{Stock stocks[STKS] = {Stock("NanoSmart", 12, 20.0),Stock("Boffo Objects", 200, 2.0),Stock("Monolithic Obelisks", 130, 3.25),Stock("Fleep Enterprises", 60, 6.5)};// 显示所有股票cout << "Stock holdings:\n";for (int i = 0; i < STKS; ++i)cout << stocks[i];// 找出总值最大的股票const Stock* top = &stocks[0];for (int i = 1; i < STKS; ++i)top = &top->topval(stocks[i]);cout << "\nMost valuable holding:\n";cout << *top << endl;return 0;
}

Stock.cpp方法定义文件

// 头文件
#include "Stock.h"
#include <cstring>// using 声明
using std::cout;
using std::endl;Stock::Stock()  // 默认构造函数
{company = nullptr;shares = 0;share_val = 0;set_tot();
}Stock::Stock(const char* co, int n, double pr)
{// 申请空间，拷贝公司名称int len = (int)strlen(co);company = new char[len + 1];strcpy(company, co);// 赋值其他成员shares = n;share_val = pr;set_tot();
}Stock::~Stock()  // 析构函数
{// 释放申请空间if (company != nullptr)delete[]company;
}void Stock::buy(int num, double pr)  // 买进
{if (num > 0){shares += num;share_val = pr;set_tot();}else{cout << "买进股票的数量不能为负";}
}void Stock::sell(int num, double pr)  // 卖出
{if (num < 0){cout << "卖出股票的数量不能为负";}else if (num > shares){cout << "卖出股票的数量不能超过自身拥有的股票数量";}else{shares -= num;share_val = pr;set_tot();}
}void Stock::update(double pr)  // 更新价格
{share_val = pr;
}// 运算符（<<）重载
std::ostream& operator<<(std::ostream& os, const Stock& s)
{os << "Company: " << s.company;os << " Shares: " << s.shares << endl;os << "  Share Price: $" << s.share_val;os << " Total Worth: $" << s.total_val << endl;return os;
}const Stock& Stock::topval(const Stock& s) const  // 返回总值大的对象
{if (total_val > s.total_val)return *this;elsereturn s;
}

4. 请看程序清单10.10定义的Stack类的变量。

#pragma once// 头文件
#include <iostream>// 类型声明
typedef unsigned long Item;// Stack 类声明
class Stack
{
private:enum { MAX = 10 };Item* pitems;int size;int top;
public:Stack(int n = MAX);Stack(const Stack& st);~Stack();bool isempty() const;bool isfull() const;bool push(const Item& item);bool pop(Item& item);Stack& operator=(const Stack& st);void get_info() const;
};

正如私有成员表明的，这个类使用动态分配的数组来保存栈中的项。请重新编写方法，以适应这种新的表示方法，并编写一个程序来演示所有的方法，包括复制构造函数和赋值运算符。

答：头文件上面有，这里就提供测试文件和方法定义文件。

main4.cpp测试文件

// 头文件
#include "Stack.h"// using 声明
using std::cout;
using std::endl;int main()
{// 默认构造函数Stack stack1;for (int i = 0; i < 5; ++i){stack1.push(i);}stack1.get_info();cout << endl;// 复制构造函数Stack stack2(stack1);stack2.get_info();cout << endl;Item tmp;stack2.pop(tmp);stack2.pop(tmp);stack2.get_info();cout << endl;// 赋值运算符stack1 = stack2;stack1.get_info();return 0;
}

Stack.cpp方法定义文件

// 头文件
#include "Stack.h"// using 声明
using std::cout;
using std::endl;Stack::Stack(int n)
{if (n > MAX){size = MAX;}else if (n > 0){size = n;}else{cout << "栈的大小不能为非正整数\n";size = top = 0;pitems = nullptr;return;}// 申请空间pitems = new Item[size];top = 0;
}Stack::Stack(const Stack& st)
{size = st.size;// 申请空间pitems = new Item[size];top = st.top;// 复制每个元素for (int i = 0; i < top; ++i)pitems[i] = st.pitems[i];
}Stack::~Stack()
{// 释放空间if (pitems != nullptr)delete pitems;
}bool Stack::isempty() const
{return top == 0;
}bool Stack::isfull() const
{return top == size;
}bool Stack::push(const Item& item)
{if (!isfull()){pitems[top++] = item;return true;}else{return false;}
}bool Stack::pop(Item& item)
{if (!isempty()){item = pitems[--top];return true;}else{return false;}
}Stack& Stack::operator=(const Stack& st)
{if (&st == this){return *this;}else{// 释放之前的空间delete[]pitems;// 申请新的空间size = st.size;pitems = new Item[size];// 赋值内容top = st.top;for (int i = 0; i < top; ++i){pitems[i] = st.pitems[i];}return *this;}
}void Stack::get_info() const
{if (pitems != nullptr){for (int i = 0; i < top; ++i){cout << pitems[i] << " ";}}
}

后面两题的答案作者没写，因为目前不是很懂，这些编程练习的答案都是我自己写的，然后运行验证的。作者今天就不加班了，偷个懒，明天早上把这两道题补上。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/18097.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

go语言函数之defer

go语言函数之defer

Go函数里面提供了defer关键字&#xff0c;可以注册多个延迟调用&#xff0c;这些调用以先进后出&#xff08;FILO&#xff09;的顺序在函数返回前被执行。这点有点类似java语言中异常处理中的的finaly子句&#xff0c;defer常用于保证一些资源最终一定能够得到回收和释放。 pa…
阅读更多...
VirtualBox+Ubuntu22.10+Docker+ROS2

VirtualBox+Ubuntu22.10+Docker+ROS2

Docker 拉取ros2镜像 docker pull osrf/ros:foxy-desktop 运行 docker run -it --nameros2 -p 50022:22 osrf/ros:foxy-desktop 进入容器安装组件 apt-get update apt-get install vim apt-get install git apt-get install net-tools # 安装ssh apt-get install openssh…
阅读更多...
Java面试题分享0519

Java面试题分享0519

目录 1、重载和重写区别&#xff1f; 2、构造器&#xff08;Constructor&#xff09;是否可被重写&#xff08;override&#xff09; 3、break 、continue 、return 作用&#xff1f; 4、JAVA 创建对象有哪些方式&#xff1f; 5、 和 equals 有什么区别&#xff1f; 6、I…
阅读更多...
centos下给es7.12.1设置密码

centos下给es7.12.1设置密码

安装可参考&#xff1a; centos7下安装elasticsearch7.8.1并配置远程连接_在一台服务器centos7上安装和配置elasticsearch。-CSDN博客 1、先停掉es进程 2、设置输入密码后访问配置 cd /home/soft/elasticsearch-7.12.1/config vim elasticsearch.yml 3、启动es服务 cd /home/…
阅读更多...
香橙派 AIpro开发板初上手

香橙派 AIpro开发板初上手

一、香橙派 AIpro开箱 最近拿到了香橙派 AIpro&#xff08;OrangePi AIpro&#xff09;&#xff0c;下面就是里面的板子和相关的配件。包含主板、散热组件、电源适配器、双C口电源线、32GB SD卡。我手上的这个是8G LPDDR4X运存的版本。 OrangePi AIpro开发板是一款由香橙派与华…
阅读更多...
VUE3 学习笔记（4）：VUE 事件处理、传参、事件修饰

VUE3 学习笔记（4）：VUE 事件处理、传参、事件修饰

常见的Web事件 页面事件 Onload --加载 Onunload --取消 Onscroll --滚动 Onresize --大小改变 表单事件 Onsubmit --提交 onchange --变更 Onselect --选择 Onreset --重置 焦点事件 Onfocus --得到焦点 Onblur --失去焦点 鼠标事件 Onclick --点击 Ondbclick --双击 onmouseu…
阅读更多...
在Python中实现限定抽奖次数的机制

在Python中实现限定抽奖次数的机制

目录 一、引言 二、需求分析 三、设计思路 四、代码实现 4.1 使用字典存储用户抽奖次数 4.2 使用数据库存储用户抽奖次数 五、扩展与优化 六、总结 一、引言 在当今互联网应用中&#xff0c;抽奖系统作为吸引用户、提高用户参与度和活跃度的重要手段&#xff0c;已经被…
阅读更多...
ideavim与vim相关笔记

ideavim与vim相关笔记

本文主要用于记录一些使用 vim/ideavim 开发的心得笔记&#xff0c;为了速度也为了折腾 强烈的个人向 笔记 ideavim 与 vim 混杂&#xff0c;无序但使用二级标题做大分类&#xff0c;当字典用,默认 vim 和 ideavim 通用&#xff0c;不通用会标记出来 文件操作 刷新重载当前打开…
阅读更多...
为什么配置了安全组还是有攻击进来？

为什么配置了安全组还是有攻击进来？

面对DDoS攻击&#xff0c;即使配置了安全组规则来限制入站流量&#xff0c;攻击者仍可能找到绕过这些基本防护措施的方法&#xff0c;尤其是当攻击流量巨大时。这是因为安全组主要工作在网络层和传输层&#xff0c;它们依据IP地址、协议和端口号来过滤流量&#xff0c;对于应用…
阅读更多...
AttributeError: module ‘numpy‘ has no attribute ‘bool‘

AttributeError: module ‘numpy‘ has no attribute ‘bool‘

报错内容&#xff1a; AttributeError: module numpy has no attribute bool. np.bool was a deprecated alias for the builtin bool. To avoid this error in existing code, use bool by itself. Doing this will not modify any behavior and is safe. If you specifically…
阅读更多...
【Spring】设计模式(GOF)

【Spring】设计模式(GOF)

Spring Framework在其架构和实现中广泛使用了多种GOF&#xff08;Gang of Four&#xff09;设计模式。这些设计模式帮助Spring解决了许多常见的软件开发问题&#xff0c;提高了代码的可重用性、可维护性和可扩展性。 1、工厂模式&#xff08;Factory Pattern&#xff09; 1.1简…
阅读更多...
Android14 WMS-窗口添加流程(一)-Client端

Android14 WMS-窗口添加流程(一)-Client端

窗口布局在onCreate方法中通过setContentView(R.layout.xxx)加载&#xff0c;但窗口的显示并不是在wm_on_create_called中, 而是在wm_on_resume_called后&#xff0c;也就是说应用onResume时此窗口是不可见的&#xff0c;真正可见是当此window窗口的mDrawState变化状态从NO_SUR…
阅读更多...
Raven2掠夺者2渡鸦2游戏预约注册教程 账号注册教程

Raven2掠夺者2渡鸦2游戏预约注册教程 账号注册教程

《渡鸦2》是一款源自韩国的创新力作&#xff0c;作为《Raven》系列的最新续篇&#xff0c;这款游戏在MMORPG手游领域内再度扩展了其标志性的暗黑奇幻宇宙&#xff0c;融入了大量革新的游戏设计与丰富内容。定档于2024年5月29日开启公测的《渡鸦2》&#xff0c;正处在紧张刺激的…
阅读更多...
blender复制uv贴图

blender复制uv贴图

1、新建两个猴头 2、点击其中一个进入uv编辑模式 3、在uv编辑中打开一个图像 4、新建一个材质球&#xff0c;将图像渲染到模型上 打开图像纹理 选择刚才打开的图像 切换到材质预览模式后&#xff0c;就可以看到贴图了 5、选择一个孤岛 6、然后选择拼排孤岛 可以看到该模型展开…
阅读更多...
【全开源】JAVA人力资源招聘社会校招类型招聘系统校园招聘PC端

【全开源】JAVA人力资源招聘社会校招类型招聘系统校园招聘PC端

塑造企业高效招聘新体验 一、源码简介 招聘PC端源码&#xff0c;一款面向企业的招聘管理系统解决方案。它拥有完整的招聘流程管理功能&#xff0c;从职位发布到候选人管理&#xff0c;再到面试安排与结果反馈&#xff0c;所有环节都通过直观易用的界面进行展现&#xff0c;大…
阅读更多...
Java面向对象-常用类(BigInteger类和BigDecemal类)

Java面向对象-常用类(BigInteger类和BigDecemal类)

常用类-BigInteger类和BigDecemal类 使用 BigDecimal 进行计算时&#xff0c;我们不能再使用算术运算符&#xff08;、-、*、/&#xff09;进行算数运算&#xff0c;而是使用 BigDecimal 类提供的 add、subtract、multiply、divide 等方法来进行算数运算。 BigInteger: 能表示比…
阅读更多...
考研408笔记总结~

考研408笔记总结~

目录 一.数据结构 二.计算机组成原理 三.操作系统 四.计算机网络 私以为边看视频&#xff0c;边做笔记会更专注些&#xff0c;大家需要自取。欢迎大家和我一起探讨考研的问题&#xff0c;包括不仅限于专业课&#xff0c;数学&#xff0c;英语等等......&#xff0c;想说什么…
阅读更多...
Vivado打开之前项目仿真过的波形文件

Vivado打开之前项目仿真过的波形文件

第一步&#xff1a;顶部菜单 点击&#xff1a;Open Static Simulation 然后在弹出的窗口找到.sim结尾的文件夹&#xff0c;在里面找到wdb结尾的文件&#xff0c;点击ok 第二步&#xff1a;依次点击下方红圈 找到wcfg结尾的文件&#xff0c;点击ok即可
阅读更多...
React：Mobx的autorun 和 runInAction（异步）

React：Mobx的autorun 和 runInAction（异步）

autorun 用法 监听变量变化 componentDidUpdate() {autorun(() > {console.log(this.list); // 每次 this.list 发生改变&#xff0c;都会触发这里// 对 list进行后续操作this.listChangeHandle();}) }⚠️注意 上边的autorun&#xff0c;会一直保留&#xff0c;每次组件加…
阅读更多...
第十三届蓝桥杯国赛大学B组填空题(c++)

第十三届蓝桥杯国赛大学B组填空题(c++)

A.2022 动态规划 AC; #include<iostream> #define int long long using namespace std; int dp[2050][15]; //dp[i][j]:把数字i分解为j个不同的数的方法数 signed main(){dp[0][0]1;for(int i1;i<2022;i){for(int j1;j<10;j){//一种是已经分成j个数,这时只需每一个…
阅读更多...
最新文章

Copyright @ 2022~2023