C++——类和对象(初始化列表和运算符重载与静态与友元)

文章目录

  • 初始化列表
    • 语法结构
    • 定义和使用
    • 案例
      • 初始化列表初始化常量成员:
    • 注意事项
  • 运算符重载
    • 加法运算符重载
      • 语法结构
      • 示例
      • 注意事项
    • 减法运算符重载
      • 语法结构
      • 示例
      • 注意事项
    • 等于运算符重载
      • 等于运算符 == 的重载语法
      • 示例
      • 注意事项
    • 大于运算符重载
      • 大于运算符 > 的重载语法
      • 示例
      • 注意事项
    • ++运算符重载
      • 前置加加运算符 (++operand)
        • 语法结构和定义
        • 示例
        • 注意事项(前置加加运算符)
      • 后置加加运算符 (operand++)
        • 语法结构和定义
        • 示例
        • 注意事项(后置加加运算符)
    • <<运算符重载
      • 语法结构和定义
      • 示例
      • 注意事项
  • 静态变量和函数
    • 静态变量(静态成员变量)
      • 语法结构和定义:
      • 案例:
      • 注意事项:
    • 静态函数(静态成员函数)
      • 语法结构和定义:
      • 案例:
      • 注意事项:
  • 友元
    • 友元函数
      • 语法结构和定义:
      • 案例:
      • 注意事项:
    • 友元类
      • 声明
      • 案例:
      • 注意事项:

初始化列表

初始化列表(initializer list)在C++中是一种用来初始化类、结构体、数组等数据结构的语法结构。它可以在定义变量时直接初始化,也可以在构造函数中初始化成员变量。

语法结构

ConstructorName(Type1 arg1, Type2 arg2, ...) : member1(arg1), member2(arg2), ... {// constructor body
}

这里是初始化列表的组成部分

ConstructorName:构造函数的名称,与类名相同。

参数列表:构造函数可以接受的参数列表,这些参数用来初始化类的成员变量。

冒号(:):初始化列表以冒号开头。

成员初始化:每个成员初始化的语法是 memberName(arg),其中 memberName 是类的成员变量名,arg 是用来初始化该成员变量的值。

构造函数体:可选的构造函数体,用来执行更多的初始化操作或者其他逻辑。

定义和使用

在变量定义时的初始化:

int arr[3] = {1, 2, 3}; // 初始化数组
std::vector<int> vec = {4, 5, 6}; 
// 初始化向量在构造函数中的初始化:
class Example {
public:int x;double y;// 构造函数使用初始化列表Example(int a, double b) : x(a), y(b) {// 构造函数体}
};

在上面的例子中,Example类的构造函数使用初始化列表来初始化成员变量x和y。

案例

初始化列表初始化成员变量:

class Point {
private:int x, y;public:// 使用初始化列表初始化成员变量Point(int x_val, int y_val) : x(x_val), y(y_val) {// 可选的构造函数体}
};

初始化列表初始化常量成员:

class Circle {
private:const double pi;double radius;public:// 初始化常量成员 piCircle(double r) : pi(3.14159), radius(r) {// 构造函数体}
};

注意事项

初始化顺序:初始化列表中的成员变量初始化顺序与它们在类中声明的顺序一致,而不是它们在初始化列表中出现的顺序。

初始化常量成员:常量成员变量(如上例中的pi)只能通过初始化列表来初始化,不能在构造函数体内赋值。

成员变量类型:初始化列表只能用于初始化非静态成员变量,静态成员变量不能在构造函数初始化列表中初始化。

没有默认值:如果类的某个成员变量没有在初始化列表中初始化,它将使用默认的构造函数进行初始化(如果有的话)。

效率:初始化列表的使用可以避免不必要的默认构造和拷贝操作,因此在效率上可能比在构造函数体内进行初始化更好。

运算符重载

加法运算符重载

语法结构

加法运算符 + 的重载语法如下:

ReturnType operator+(const ClassName& obj) {// 加法运算的实现// 可以访问对象的成员变量和方法return ReturnType(result);
}

其中:

  • ReturnType:是加法运算的结果类型,可以是对象、引用或者基本数据类型。
  • operator+:是加法运算符的函数名,用于重载加法运算符。
  • ClassName:是定义加法运算符的类名。
  • const ClassName& obj:是右操作数,即用于与当前对象进行加法运算的对象。

函数体内部实现了加法的逻辑,并返回加法结果。

示例

下面是一个使用加法运算符重载的示例:

#include <iostream>class Complex {
private:double real;double imag;public:Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}// 重载加法运算符+Complex operator+(const Complex& other) {Complex temp;temp.real = real + other.real;temp.imag = imag + other.imag;return temp;}void display() {std::cout << real << " + " << imag << "i" << std::endl;}
};int main() {Complex c1(2.3, 4.5);Complex c2(3.4, 5.6);Complex c3;c3 = c1 + c2; // 使用重载的+运算符std::cout << "Sum of ";c1.display();std::cout << "and ";c2.display();std::cout << "is ";c3.display();return 0;
}

在这个例子中,Complex类表示复数,重载了加法运算符 +,使得可以对两个 Complex 对象进行相加操作。在 main() 函数中,创建了两个复数对象 c1 和 c2,然后通过 c1 + c2 进行加法运算,并将结果赋给 c3。

注意事项

参数类型:通常情况下,加法运算符重载的参数应当是同类的对象或者可以转换为同类对象的类型。

返回类型:加法运算符重载函数通常返回一个新的对象,代表加法的结果。

修改对象:一般情况下,不应该在加法运算符重载中修改参数对象本身的状态,而是应当返回一个新的对象表示结果。

友元函数:如果需要在加法运算符重载函数中访问私有成员变量,可以将其声明为友元函数。

连续加法:重载的加法运算符也支持链式调用,例如 c1 + c2 + c3。

保持语义一致性:加法运算符重载的结果应当符合加法的数学意义,并且不应引入歧义或者不合理的行为。

减法运算符重载

当涉及到在 C++ 中重载减法运算符 - 时,它与重载加法运算符类似,允许用户定义对自定义类型的减法操作。下面是减法运算符重载的语法结构、示例和一些注意事项:

语法结构

减法运算符 - 的重载语法如下:

ReturnType operator-(const ClassName& obj) {// 减法运算的实现// 可以访问对象的成员变量和方法return ReturnType(result);
}

其中:

  • ReturnType:是减法运算的结果类型,可以是对象、引用或者基本数据类型。
  • operator-:是减法运算符的函数名,用于重载减法运算符。
  • ClassName:是定义减法运算符的类名。
  • const ClassName& obj:是右操作数,即用于与当前对象进行减法运算的对象。

函数体内部实现了减法的逻辑,并返回减法结果。

示例

下面是一个使用减法运算符重载的示例,假设我们仍然使用复数 Complex 类:

#include <iostream>class Complex {
private:double real;double imag;public:Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}// 重载减法运算符-Complex operator-(const Complex& other) {Complex temp;temp.real = real - other.real;temp.imag = imag - other.imag;return temp;}void display() {std::cout << real << " + " << imag << "i" << std::endl;}
};int main() {Complex c1(5.7, 8.4);Complex c2(3.2, 1.6);Complex c3;c3 = c1 - c2; // 使用重载的-运算符std::cout << "Difference of ";c1.display();std::cout << "and ";c2.display();std::cout << "is ";c3.display();return 0;
}

在这个示例中,Complex 类再次表示复数,重载了减法运算符 -,允许对两个 Complex 对象进行减法操作。在 main() 函数中,创建了两个复数对象 c1 和 c2,然后通过 c1 - c2 进行减法运算,并将结果赋给 c3。

注意事项

参数类型和返回类型:与加法运算符类似,减法运算符重载函数的参数应当是同类的对象或者可以转换为同类对象的类型,返回类型通常是表示减法结果的新对象。

对象状态:遵循良好的实践,不要在减法运算符重载中修改参数对象本身的状态,而是应当返回一个新的对象表示结果。

友元函数:如有需要,可以将减法运算符重载函数声明为友元函数以访问私有成员变量。

连续减法:重载的减法运算符同样支持链式调用,例如 c1 - c2 - c3。

语义一致性:确保减法运算符重载的行为符合减法的数学定义,避免引入歧义或者不合理的操作。

等于运算符重载

当你在 C++ 中重载等于运算符 ==,你可以自定义两个对象相等的条件。这种重载允许你用更符合你自定义类型特性的方式来比较对象的相等性。

等于运算符 == 的重载语法

等于运算符的重载语法如下:

bool operator==(const ClassName& obj) const {// 判断当前对象和参数对象是否相等的逻辑// 返回 true 表示相等,返回 false 表示不相等
}

其中:

  • bool:等于运算符需要返回一个布尔值,表示对象是否相等。
  • operator==:是等于运算符的函数名,用于重载等于运算符。
  • ClassName:是定义等于运算符的类名。
  • const ClassName& obj:是右操作数,即用于与当前对象进行比较的对象。

const 关键字和成员函数后面的 const 保证了该成员函数不会修改对象的成员变量。

示例

假设我们继续使用复数 Complex 类来示范等于运算符的重载:

#include <iostream>class Complex {
private:double real;double imag;public:Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}// 重载等于运算符==bool operator==(const Complex& other) const {return (real == other.real) && (imag == other.imag);}void display() const {std::cout << real << " + " << imag << "i" << std::endl;}
};int main() {Complex c1(2.0, 3.0);Complex c2(2.0, 3.0);Complex c3(4.0, 1.5);if (c1 == c2) {std::cout << "c1 and c2 are equal." << std::endl;} else {std::cout << "c1 and c2 are not equal." << std::endl;}if (c1 == c3) {std::cout << "c1 and c3 are equal." << std::endl;} else {std::cout << "c1 and c3 are not equal." << std::endl;}return 0;
}

在这个示例中,Complex 类重载了等于运算符 ==,以便比较两个复数对象的实部和虚部是否相等。在 main() 函数中,创建了三个复数对象 c1、c2 和 c3,并使用 c1 == c2 和 c1 == c3 来演示等于运算符的使用。

注意事项

语义一致性:确保你的等于运算符重载与你的类型的语义一致。比如,在复杂类型中,可能需要比较多个成员变量而不仅仅是一个。

友元函数:如有必要,等于运算符重载可以声明为友元函数,以便访问私有成员变量。

对称性:等于运算符应当是对称的,即 a == b 应当和 b == a 具有相同的效果。

大于运算符重载

大于运算符 > 的重载语法

大于运算符的重载语法与等于运算符类似,它允许您自定义两个对象之间的大小比较条件。

bool operator>(const ClassName& obj) const {// 判断当前对象是否大于参数对象的逻辑// 返回 true 表示当前对象大于参数对象,返回 false 表示不大于
}

其中:

  • bool:大于运算符需要返回一个布尔值,表示当前对象是否大于参数对象。
  • operator>:是大于运算符的函数名,用于重载大于运算符。
  • ClassName:是定义大于运算符的类名。
  • const ClassName& obj:是右操作数,即用于与当前对象进行比较的对象。

const 关键字和成员函数后面的 const 保证了该成员函数不会修改对象的成员变量。

示例

继续使用之前的 Complex 类来演示大于运算符的重载:

#include <iostream>class Complex {
private:double real;double imag;public:Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}// 重载大于运算符>bool operator>(const Complex& other) const {// 比较复数的模(模长)double this_modulus = real * real + imag * imag;double other_modulus = other.real * other.real + other.imag * other.imag;return this_modulus > other_modulus;}void display() const {std::cout << real << " + " << imag << "i" << std::endl;}
};int main() {Complex c1(2.0, 3.0);Complex c2(4.0, 1.5);if (c1 > c2) {std::cout << "c1 is greater than c2." << std::endl;} else {std::cout << "c1 is not greater than c2." << std::endl;}return 0;
}

在这个示例中,Complex 类重载了大于运算符 >,以便比较两个复数对象的模(即模长)是否满足大于关系。在 main() 函数中,创建了两个复数对象 c1 和 c2,并使用 c1 > c2 来演示大于运算符的使用。

注意事项

语义一致性:确保您的大于运算符重载与您的类型的语义一致。比如,在复杂类型中,可能需要比较多个成员变量而不仅仅是一个。

友元函数:如有必要,大于运算符重载可以声明为友元函数,以便访问私有成员变量。

对称性:大于运算符应当是对称的,即 a > b 应当和 b < a 具有相同的效果。

++运算符重载

当我们讨论 “++” 运算符在 C++ 中的重载时,通常会涉及到两种形式:前置加加运算符(++operand)和后置加加运算符(operand++)。下详细解释这两种运算符的重载语法结构、定义、案例和注意事项。

前置加加运算符 (++operand)

语法结构和定义

前置加加运算符 ++ 的重载形式如下:

ReturnType operator++() {// 增加操作数的值// 返回增加后的操作数
}

其中:

  • ReturnType:是返回值的类型,通常是引用类型,以便支持连续操作。
  • operator++:是前置加加运算符的函数名,用于重载前置加加运算符。
  • ():代表这是一个函数调用。

操作数被隐式地作为当前对象(this)传递给运算符函数。

示例

以下是一个示例,演示了如何重载前置加加运算符:

#include <iostream>class Integer {
private:int value;public:Integer(int v = 0) : value(v) {}// 重载前置加加运算符++Integer& operator++() {++value;return *this;}void display() const {std::cout << "Value: " << value << std::endl;}
};int main() {Integer num(5);++num;  // 使用前置加加运算符num.display();  // 输出 Value: 6return 0;
}

在这个示例中,Integer 类重载了前置加加运算符 ++,使得可以直接对 Integer 类型的对象进行自增操作。

注意事项(前置加加运算符)

返回类型:通常应该返回引用类型 ReturnType&,以支持链式调用和修改对象本身。

副作用:前置加加运算符会直接修改对象的值,应该确保操作的一致性和正确性。

成员函数声明:通常应将前置加加运算符声明为类的成员函数,以便访问对象的私有成员变量。

后置加加运算符 (operand++)

语法结构和定义

后置加加运算符 ++ 的重载形式如下:

ReturnType operator++(int) {// 创建一个副本以便于后续返回// 增加操作数的值// 返回之前的副本
}

其中:

  • ReturnType:是返回值的类型,通常是原始类型(非引用)。
  • operator++:是后置加加运算符的函数名,用于重载后置加加运算符。
  • (int):这是一个额外的参数,但通常不使用该参数。
示例

以下是一个示例,演示了如何重载后置加加运算符:

#include <iostream>class Integer {
private:int value;public:Integer(int v = 0) : value(v) {}// 重载后置加加运算符++Integer operator++(int) {Integer temp(value);  // 创建一个副本++value;  // 增加操作数的值return temp;  // 返回之前的副本}void display() const {std::cout << "Value: " << value << std::endl;}
};int main() {Integer num(5);Integer old_num = num++;  // 使用后置加加运算符num.display();  // 输出 Value: 6old_num.display();  // 输出 Value: 5return 0;
}

在这个示例中,Integer 类重载了后置加加运算符 ++,返回原始值的副本,并在返回之前增加了对象的值。

注意事项(后置加加运算符)

返回类型:通常应该返回对象的原始类型,而不是引用,以避免悬挂引用问题。
参数:后置加加运算符通常需要一个额外的 int 参数(可以不使用),用于区分前置和后置形式。
效率:后置加加运算符需要创建一个对象的副本,因此可能比前置加加运算符稍慢。

<<运算符重载

重载左移运算符 << 在 C++ 中常用于自定义类的输出格式,使得类对象可以像内置类型一样直接输出到标准输出流(如 std::cout)。下面详细解释如何在 C++ 中重载左移运算符 <<。

语法结构和定义

左移运算符 << 的重载形式如下:

ReturnType operator<<(std::ostream& os, const YourClass& obj) {// 输出 obj 到 ostream os 中return os;  // 返回 ostream 对象
}

其中:

  • ReturnType:通常是 std::ostream&,因为左移运算符重载的目的是为了支持链式输出。
  • operator<<:是左移运算符的函数名,用于重载左移运算符。
  • std::ostream& os:是输出流对象的引用,如 std::cout。
  • const YourClass& obj:是要输出的类对象的引用,通常是常量引用以避免不必要的复制。

示例

以下是一个示例,演示了如何重载左移运算符 <<:

#include <iostream>class Point {
private:int x;int y;public:Point(int x = 0, int y = 0) : x(x), y(y) {}// 重载左移运算符<<friend std::ostream& operator<<(std::ostream& os, const Point& obj) {os << "Point(" << obj.x << ", " << obj.y << ")";return os;}
};int main() {Point p1(3, 4);Point p2(-1, 8);std::cout << "Point p1: " << p1 << std::endl;std::cout << "Point p2: " << p2 << std::endl;return 0;
}

在这个示例中,Point 类重载了左移运算符 <<,使得可以直接输出 Point 对象到标准输出流 std::cout 中。

注意事项

友元函数:通常将左移运算符重载函数声明为类的友元函数,以便访问类的私有成员变量。

返回类型:应该返回 std::ostream& 类型,以支持链式输出。

引用参数:对象参数应该是常量引用 const YourClass&,避免不必要的复制。

静态变量和函数

在C++中,静态变量(静态成员变量)和静态函数(静态成员函数)属于类的静态成员,它们不依赖于类的实例而存在,而是与类本身关联。以下是它们的语法结构、定义、案例和注意事项:

静态变量(静态成员变量)

语法结构和定义:

静态成员变量由关键字 static 声明,通常在类的声明中定义,但在类的定义外初始化。

定义格式为:static type variable_name;

class MyClass {
public:static int count;// other members...
};// 类的定义外部初始化
int MyClass::count = 0;

案例:

#include <iostream>class MyClass {
public:static int count;MyClass() {count++;}
};int MyClass::count = 0;int main() {MyClass obj1;MyClass obj2;MyClass obj3;std::cout << "Number of objects created: " << MyClass::count << std::endl;return 0;
}

输出:

Number of objects created: 3

注意事项:

  • 静态变量被所有类对象共享,它们在程序的生命周期内只有一份实例。

  • 静态成员变量必须在类的定义外部进行初始化。

  • 可以通过类名和作用域解析运算符 :: 来访问静态成员变量,如 MyClass::count。

静态函数(静态成员函数)

语法结构和定义:

静态成员函数也由关键字 static 声明。

静态函数可以直接访问类的静态成员变量和其他静态成员函数,但不能直接访问非静态成员变量和非静态成员函数。

定义格式为:static return_type function_name(parameters);
class MyClass {
public:static void staticFunction() {std::cout << "This is a static function." << std::endl;}
};

案例:

#include <iostream>class MyClass {
public:static void staticFunction() {std::cout << "This is a static function." << std::endl;}void normalFunction() {std::cout << "This is a normal function." << std::endl;}
};int main() {MyClass::staticFunction();MyClass obj;obj.normalFunction();// Accessing static function through object (not recommended):obj.staticFunction(); // valid but not recommendedreturn 0;
}

输出

This is a static function.
This is a normal function.
This is a static function.

注意事项:

  • 静态函数不能直接访问非静态成员变量或非静态成员函数,因为它们没有隐含的 this 指针。

  • 可以通过类名直接调用静态函数,也可以通过对象调用静态函数,但不推荐后者,因为静态函数不依赖于具体对象。

友元

友元(friend)在C++中是一种机制,允许某些函数或类访问另一个类的私有成员。友元可以是一个函数、一个类、或者整个类中的所有函数。这种机制打破了C++中的封装性,因此需要谨慎使用。

友元函数

语法结构和定义:

友元函数声明在目标类的内部,但定义在类的外部。

友元函数的声明以关键字 friend 开始,后面跟随函数原型。
class MyClass {
private:int privateData;public:MyClass() : privateData(0) {}friend void friendFunction(MyClass &obj);
};void friendFunction(MyClass &obj) {// 友元函数可以访问目标类的私有成员obj.privateData = 100;
}

案例:

#include <iostream>class MyClass {
private:int privateData;public:MyClass() : privateData(0) {}friend void friendFunction(MyClass &obj);void displayPrivateData() {std::cout << "Private data: " << privateData << std::endl;}
};void friendFunction(MyClass &obj) {obj.privateData = 100; // 可以访问私有成员 privateData
}int main() {MyClass obj;friendFunction(obj); // 调用友元函数obj.displayPrivateData(); // 输出 Private data: 100return 0;
}

输出

Private data: 100

注意事项:

  • 友元函数并不是目标类的成员函数,它没有 this 指针,因此不能直接访问类的成员。
  • 友元函数在访问目标类的私有成员时不受访问权限限制。
  • 友元函数的声明需要在目标类中进行,但定义可以在类外部进行。
    友元类

除了友元函数,C++还支持友元类,即一个类可以将另一个类声明为自己的友元,这样被声明的友元类就可以访问声明它为友元的类的所有成员,包括私有成员。

友元类

声明

class FriendClass {
public:void accessMyClassPrivateData(MyClass &obj) {obj.privateData = 200; // 可以访问目标类的私有成员}
};class MyClass {
private:int privateData;friend class FriendClass; // 声明FriendClass为友元类public:MyClass() : privateData(0) {}void displayPrivateData() {std::cout << "Private data: " << privateData << std::endl;}
};

案例:

#include <iostream>class FriendClass {
public:void accessMyClassPrivateData(MyClass &obj) {obj.privateData = 200; // 可以访问目标类的私有成员}
};class MyClass {
private:int privateData;friend class FriendClass; // 声明FriendClass为友元类public:MyClass() : privateData(0) {}void displayPrivateData() {std::cout << "Private data: " << privateData << std::endl;}
};int main() {MyClass obj;FriendClass friendObj;friendObj.accessMyClassPrivateData(obj); // 通过友元类访问私有成员obj.displayPrivateData(); // 输出 Private data: 200return 0;
}

输出

 Private data: 200

注意事项:

  • 友元类的声明会影响整个类的封装性,因此应慎重考虑使用。
  • 友元关系是单向的,声明了 A 类为 B 类的友元并不意味着 B 类也是 A 类的友元。
  • 友元关系不能被继承,子类不能访问父类的友元。

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

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

相关文章

mac如何查看cpu和显卡温度

在Mac上查看CPU和显卡温度&#xff0c;你可以使用以下几种方法&#xff1a; 方法1&#xff1a;使用内建工具“活动监视器” 虽然“活动监视器”不能直接显示温度信息&#xff0c;但它可以显示CPU使用情况等信息。 打开“活动监视器”&#xff0c;可以通过以下路径找到&#…

JavaScript 常见数学用法

JavaScript 数学 JavaScript Math 对象允许您对数字执行数学任务。 实例&#xff1a; Math.PI; 返回 3.141592653589793常见案例 Math.round() Math.round(x) 的返回值是 x 四舍五入为最接近的整数&#xff1a; 实例&#xff1a; Math.round(6.8); // 返回 7 Math.r…

JavaWeb入门程序解析(Spring官方骨架、配置起步依赖、SpringBoot父工程、内嵌Tomcat)

3.3 入门程序解析 关于web开发的基础知识&#xff0c;我们可以告一段落了。下面呢&#xff0c;我们在基于今天的核心技术点SpringBoot快速入门案例进行分析。 3.3.1 Spring官方骨架 之前我们创建的SpringBoot入门案例&#xff0c;是基于Spring官方提供的骨架实现的。 Sprin…

python初学之路

一、python入门&#xff1a; https://mp.weixin.qq.com/mp/appmsgalbum?__bizMzI2NDU3NjIzMQ&actiongetalbum&album_id3244362729562406922&scene173&subscene&sessionidsvr_ca72c6eb974&enterid1721214755&from_msgid2247487445&from_itemi…

勘测院如何实现可控便捷的图纸安全外发?

勘测院&#xff0c;也称为勘测设计研究院或勘测设计院&#xff0c;是进行与地质、地形和地貌有关的勘察测量的单位&#xff0c;为各类工程项目提供准确的地质数据和设计依据。 勘测院会产生各类包括图纸在内的文件&#xff0c;如&#xff1a; 1、项目相关文件&#xff1a;项目…

LocalDate类型序列化成JSON时格式错误(已解决)

问题背景&#xff1a; 对象&#xff1a;projectTaskDto对象有日期属性 {planStartTime&#xff1a;"2024-07-10" } 使用 writeValueAsString方法序列化成json格式后&#xff1a; ObjectMapper objectMapper new ObjectMapper(); String jsonRequest objectMapp…

c++模板初阶----函数模板与类模板

目录 泛型编程 函数模板 函数模板的概念 函数模板的格式 函数模板的原理 函数模板的实例化 函数模板的匹配原则 类模板 类模板的定义格式 类模板的实例化 c的模板大致可以分为&#xff1a; 函数模板类模板 首先在我们引入模板之前&#xff0c;先进行介绍泛型编程 泛…

期权黑天鹅怎么应对?近期很有可能发生的事情!

今天带你了解期权黑天鹅怎么应对&#xff1f;在当今世界&#xff0c;投资者们不断地寻找着各种策略来应对市场的波动和不确定性。其中&#xff0c;黑天鹅策略在近年来逐渐受到了广泛的关注&#xff0c;这种策略主要是利用极端事件&#xff0c;例如突发事件或自然灾害等难以预测…

【React笔记初学总结一】React新手的学习流程笔记总结,掰开了揉碎了,下载安装基础结构学习

REACT学习记录 一、React是什么&#xff1a;二、尝试安装下载&#xff1a;三、理解都有什么四、基础网页学习&#xff1a;1.几个比较重要的资源包例子2.第一个react示例&#xff1a;&#xff08;掰开了揉碎了&#xff0c;咱们先看懂它最简单的结构&#xff09;3.第二个react示例…

深入Laravel的魔法核心:依赖注入的工作原理

深入Laravel的魔法核心&#xff1a;依赖注入的工作原理 在现代软件开发中&#xff0c;依赖注入&#xff08;Dependency Injection&#xff0c;DI&#xff09;是一种设计模式&#xff0c;它允许开发者将组件的依赖关系从组件本身中解耦出来&#xff0c;从而提高代码的灵活性和可…

常用的系统层安全机制

目录 1. SafeSEH2. DEP3. PIE4. NX5. ASLR6. SEHOP7. GS 为应对各种各样的网络攻击&#xff0c;操作系统内部有很多底层的安全机制。而每一种安全机制&#xff0c;都对应了一定形式的网络攻击方法。 攻击队的能力是指掌握这些系统层安全机制的技术原理&#xff0c;能够发现程序…

javafx、node js、socket、OpenGL多线程

机器学习、算法、人工智能、汇编&#xff08;mips、arm、8086&#xff09;、操作系统、数据挖掘、编译原理、计算机网络、Arena软件、linux xv6、racket、shell、Linux、PHP、Haskell、Scala、spark、UML、mathematica、GUI、javafx、node js、socket、OpenGL、多线程、qt、数据…

C++链接FTP服务器并下载数据(在qt中编写)

.pro文件 #------------------------------------------------- # # Project created by QtCreator 2024-07-16T13:19:03 # #-------------------------------------------------QT core gui networkgreaterThan(QT_MAJOR_VERSION, 4): QT widgetsTARGET untitled TE…

Qt实现IP地址输入框-自定义控件

在 许多应用程序中&#xff0c;我们经常需要使用IP地址。为了方便用户输入和处理&#xff0c;一个好的解决方案是使用自定义控件。本示例代码使用Qt编写一个名为“IPAddress”的自定义控件来实现IP地址的输入功能。通过使用此控件&#xff0c;用户可以方便地输入和处理IP地址。…

吴恩达机器学习笔记 三十八 二进制标签 均值归一化

标签 0 和 1 可以有很多种意义。从回归到二分分类&#xff1a;之前定义 ,而对于二进制标签&#xff0c;通过给出y^(i,j)为 1 的概率&#xff0c;其中 损失函数 均值归一化 计算每个电影的平均得分&#xff0c;例如第一部电影的平均分为2.5&#xff0c;第五部电影的平均分为1.2…

如何在excel表中实现单元格满足条件时整行变色?

可以试试使用条件格式&#xff1a; 一、条件格式 所谓“自动变色”就要使用条件格式。 先简单模拟数据如下&#xff0c; 按 B列数字为偶数 为条件&#xff0c;整行标记为蓝色背景色。 可以这样设置&#xff1a; 先选中1:10行数据&#xff0c;在这里要确定一下名称栏里显示…

pico+unity3d手部动画

在 Unity 开发中&#xff0c;输入系统的选择和运用对于实现丰富的交互体验至关重要。本文将深入探讨 Unity 中的 Input System 和 XR Input Subsystem 这两种不同的输入系统&#xff0c;并详细介绍它们在控制手部动画方面的应用。 一、Input System 和 XR Input Subsystem 的区…

高并发解决方案总结

高并发是指在短时间内有大量的用户同时访问系统或服务&#xff0c;导致系统压力剧增&#xff0c;可能出现响应延迟、服务不可用等问题。针对高并发问题&#xff0c;有多种解决方案&#xff0c;以下是一些主要的解决方案&#xff1a; 一、架构层面 负载均衡&#xff1a; 将多…

Java性能优化-书写高质量SQL的建议(如何做Mysql优化)

场景 Mysql中varchar类型数字排序不对踩坑记录&#xff1a; Mysql中varchar类型数字排序不对踩坑记录_mysql vachar排序有问题-CSDN博客 为避免开发过程中针对mysql语句的写法再次踩坑&#xff0c;总结开发过程中常用书写高质量sql的一些建议。 注&#xff1a; 博客&#…

什么是智能家居?

智能家居&#xff0c;也称为家庭自动化&#xff0c;是一种将科技力量融入日常生活的革命性生活方式。它通过将家中的各种设备&#xff08;如照明、音响、空调、通风机、报警器、电动窗帘、传感器以及各类家电&#xff09;通过专用的网络连接在一起&#xff0c;实现自动控制、远…