条件编译代码记录

news2024/9/20 20:02:24 
#include <iostream>

// 基类模板
template<typename T>
class Base {
public:
	void func() {
		std::cout << "Base function" << std::endl;
	}
};

// 特化的子类
template<typename T>
class Derived : public Base<T> {
public:
	void func() {
		std::cout << "Derived function" << std::endl;
	}
};

// 完全特化的子类
template<>
class Derived<int> : public Base<int> {
public:
	void func() {
		std::cout << "Specialized Derived<int> function" << std::endl;
	}
};

int main() {
	Derived<double> d1;  // 这个对象使用的是 Derived<double>
	d1.func();           // 输出: "Derived function"

	Derived<int> d2;     // 这个对象使用的是完全特化的 Derived<int>
	d2.func();           // 输出: "Specialized Derived<int> function"

	Base<double> b;      // 基类实例
	b.func();            // 输出: "Base function"

	return 0;
}

std::enable_if_t<std::is_same_v<U, Dim3>, Ptr> 如何使用？

#include <iostream>
#include <type_traits>

// 定义不同的MyType子类型
class MyTypeA {
public:
	void process() {
		std::cout << "Processing MyTypeA" << std::endl;
	}
};

class MyTypeB {
public:
	void process() {
		std::cout << "Processing MyTypeB" << std::endl;
	}
};

class MyTypeC {
public:
	void process() {
		std::cout << "Processing MyTypeC" << std::endl;
	}
};

// 函数模板，用于处理MyTypeA
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeA>, void> process(T& obj) {
	obj.process(); // 处理MyTypeA
}

// 函数模板，用于处理MyTypeB
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeB>, void> process(T& obj) {
	obj.process(); // 处理MyTypeB
}

// 函数模板，用于处理MyTypeC
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeC>, void> process(T& obj) {
	obj.process(); // 处理MyTypeC
}

template <typename U>
void templateFunction(U& obj) {
	process(obj); // 调用具体的process函数
}

int main() {
	MyTypeA myObjA;
	MyTypeB myObjB;
	MyTypeC myObjC;

	templateFunction(myObjA);  // 输出: Processing MyTypeA
	templateFunction(myObjB);  // 输出: Processing MyTypeB
	templateFunction(myObjC);  // 输出: Processing MyTypeC

	// 如果你尝试以下代码，将导致编译错误：
	// std::string str; // 这里是一个不支持的类型
	// templateFunction(str); // 编译错误，因为没有对应的process函数处理std::string
}

if constexpr (std::is_same_v< >和std::enable_if_t<std::is_same_v>有什么区别 

template<typename T, typename U>；

std::enable_if_t<std::is_same_v<U, Dim3>, void> 代码里可以对T和U多条件判断吗？

对模板参数 T 和 U 进行多条件判断。在 C++ 中，可以通过使用 std::enable_if、constexpr 表达式以及组合多种类型特性（比如 std::is_integral、std::is_floating_point 等）来实现复杂的条件逻辑。

以下是几种常见的方法来对 T 和 U 进行多条件判断：

1. 使用 std::enable_if

可以将多个条件组合在一起，例如使用逻辑运算符 && 或 ||。以下是示例代码：

#include <type_traits>

template<typename T, typename U>
class Shaper {
public:
    // 当 T 是整型且 U 是 Dim3 时，启用 reshape 函数
    template<typename = std::enable_if_t<std::is_integral<T>::value && std::is_same_v<U, Dim3>>>
    void reshape(float* data, ...) {
        // 实现
    }

    // 另外一个 reshape 函数，当 U 是其他类型时（例如，浮点型）
    template<typename = std::enable_if_t<std::is_floating_point<U>::value>>
    void reshape(float* data, ...) {
        // 实现其他逻辑
    }
};

2. 通过类型萃取和其他类型特性进行组合

您可以还可以使用组合类型特性进行更复杂的判断：

#include <type_traits>

template<typename T, typename U>
class Shaper {
public:
    // 当 T 是整型且 U 是 Dim3 或者 U 是某个其他类型时启用 reshape 函数
    template<typename = std::enable_if_t<std::is_integral<T>::value && (std::is_same_v<U, Dim3> || std::is_floating_point<U>::value)>>
    void reshape(float* data, ...) {
        // 实现
    }
};

3. 组合多个 enable_if 条件

您也可以在模板上直接组合多个 enable_if 条件：

#include <type_traits>

template<typename T, typename U>
class Shaper {
public:
    template<typename = std::enable_if_t<std::is_integral<T>::value && std::is_same_v<U, Dim3> && SomeOtherCondition<U>::value>>
    void reshape(float* data, ...) {
        // 实现
    }
};

has_value_member


// 模板函数，只有在T没有value成员时才会启用
template<typename T>
typename std::enable_if<!has_value_member<T>::value>::type

#include <iostream>
#include <type_traits>

// 用于检测类型T是否有一个名为 value_type 的类型成员
template <typename T, typename = void>
struct has_value_type : std::false_type {};

// 特化 if 提供实现
template <typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

// 一个示例结构体，具备 value_type
struct StructWithValue {
	using value_type = int; // 定义类型成员
	value_type value; // 实例成员
};

// 一个不具备 value_type 的结构体
struct StructWithoutValue {
	double value; // 没有定义类型成员value_type
};

template<typename T, typename Enable = void>
class Widget;

// 特化 Widget，当T有value_type时
template<typename T>
class Widget<T, typename std::enable_if<has_value_type<T>::value>::type> {
public:
	void printIfHasValue() {
		std::cout << "T has value type member." << std::endl;
	}
};

// 特化 Widget，当T没有value_type时
template<typename T>
class Widget<T, typename std::enable_if<!has_value_type<T>::value>::type> {
public:
	void print() {
		std::cout << "This type doesn't have a value_type member." << std::endl;
	}
};

int main() {
	Widget<StructWithValue> wa;
	wa.printIfHasValue(); // 正确: T是有值类型成员的结构体
	
	Widget<StructWithoutValue> wb;
	wb.print(); // 输出: This type doesn't have a value_type member.

	return 0;
}

多模版参数处理

template <typename T, typename U,bool DeviceType>，有时需要template <typename T, typename U, typename D,bool DeviceType>,怎么设计呢？

1特化：

#include <iostream>
#include <type_traits>

// 主模板，使用 std::conditional 选取 D 类型
template <typename T, typename U, bool DeviceType, typename D = void>
class MyTemplate;

// 特化，处理只有两个类型和布尔值的情况
template <typename T, typename U, bool DeviceType>
class MyTemplate<T, U, DeviceType, void> {
public:
	void print() {
		std::cout << "Using template with two types (T, U) and a bool." << std::endl;
	}
};

// 特化，处理带有第三个类型 D 的情况
template <typename T, typename U, typename D, bool DeviceType>
class MyTemplate<T, U, DeviceType, D> {
public:
	void print() {
		std::cout << "Using template with two types (T, U), an additional type (D), and a bool." << std::endl;
	}
};

int main() {
	MyTemplate<int, double, true> instance1;  // 使用两个类型的模板
	instance1.print();

	MyTemplate<int, double, true, char> instance2;  // 使用三个类型的模板
	instance2.print();

	return 0;
}

特化二：

#include <iostream>
#include <type_traits>

// 基本模板，两个类型和一个布尔值
template <typename T, typename U, typename D = void, bool DeviceType = false>
class MyTemplate {
public:
	void print() {
		std::cout << "Using template with T, U, D (defaulted), and DeviceType." << std::endl;
	}
};

// 特化版本，当 D 不是 void 时
template <typename T, typename U, typename D>
class MyTemplate<T, U, D, true> {
public:
	void print() {
		std::cout << "Using template with T, U, and a third type D, with DeviceType set to true." << std::endl;
	}
};

int main() {
	MyTemplate<int, double> myInstance1; // 使用默认的D为void，DeviceType为false
	myInstance1.print();

	MyTemplate<int, double, char, true> myInstance2; // 指定了D和DeviceType
	myInstance2.print();

	return 0;
}

 

当您希望根据条件选择不同数量的模板参数时，一种常见的方法是使用递归模板或辅助结构如类型特征来处理这种情况。然而，对于您提出的特定需求（即有条件地在模板中使用额外的类型参数），一种实际的方法是使用模板偏特化和默认模板参数联合使用，但不能通过改变参数数量的方式来实现。

下面我们将使用默认模板参数和SFINAE（Substitution Failure Is Not An Error）技巧来提供一个解决方案。

方案说明

一个更实用的方法是设计一个包裹类型或使用一个已经存在的如 std::enable_if，std::conditional 或自定义类型特征来根据条件启用或禁用第三个类型参数。但对于直接添加或移除模板参数，在C++模板中这是不可能实现的。取而代之的是，我们可以按需使用第三个类型参数，让它在某些情况下为 void 类型或其他不影响的类型。

改进后的例子

考虑到上述限制，如果我们要实现一个这样的结构，我们必须以稍微不同的方式思考。以下是一种使用 std::conditional 来选择第三个参数是一个有效类型还是 void 的方法。此方法并不完美，但展示了如何基于给定的布尔值 DeviceType 来静态选择类型。

#include <iostream>
#include <type_traits>

template <typename T, typename U, bool DeviceType, typename D = void>
class MyTemplate {
public:
    using ConditionallyEnabledType = typename std::conditional<DeviceType, D, void>::type;

    void print() {
        if constexpr (std::is_same<ConditionallyEnabledType, void>::value) {
            std::cout << "Template with T, U, and DeviceType, D is void." << std::endl;
        } else {
            std::cout << "Template with T, U, DeviceType and D as an additional type." << std::endl;
        }
    }
};

int main() {
    MyTemplate<int, double, false> myInstance1; // D will be considered void
    myInstance1.print();

    MyTemplate<int, double, true, char> myInstance2; // D will be enabled as 'char'
    myInstance2.print();

    return 0;
}

 

为什么不完美？

你的代码使用了模板的SFINAE（Substitution Failure Is Not An Error）技术，来根据编译时的条件（是否指定了类型参数D）来选择性地启用某个类型。这个设计对于特定模板类的某些条件来说是有效的，但有几个潜在的问题和局限性需要注意：

  1. 模板参数默认值不完整：你的模板参数D默认值是void，这会导致在某些情况下不完全匹配预期行为。如果DeviceType为false，你默认没有为D提供任何类型信息，这使得编译器难以解析你的模板，因为它无法确定哪个类型是默认的。虽然你的代码可能能够编译成功，但这种不明确性可能会导致混淆或误解。通常更好的做法是明确指定所有模板参数的类型，即使它们有默认值。

  2. 模板参数不完整：你的模板类依赖于一个布尔值来决定是否启用某个类型，这种设计对于特定的用例可能是有效的，但它限制了模板的灵活性。如果模板设计用于更广泛的用途，可能需要更复杂的逻辑来根据多个条件启用或禁用类型。此外，使用布尔值作为模板参数通常不是一个好的做法，因为它增加了代码与特定编译逻辑的耦合性。更常见的是使用条件模板或别名来达成同样的效果。

针对这些问题，一个改进的方式是重新定义模板以考虑所有的参数依赖和上下文，比如：

template <typename T, typename U> // 无需显式的DeviceType和D类型参数，因为这些可以作为函数内部逻辑的一部分处理
class MyTemplate {
public:
    template <typename D = void> // 使用默认模板参数来处理可能的额外类型D
    void print() { // 此函数将根据是否提供了额外的类型D来处理不同的逻辑
        if constexpr (std::is_void<D>::value) { // 使用std::is_void而不是直接比较来检查类型是否为void
            std::cout << "Template with T and U." << std::endl; // 根据是否提供了额外的类型输出不同的消息
        } else {
            std::cout << "Template with T, U, and additional type D." << std::endl;
        }
    }
};
```在这个修改中，`DeviceType`是隐藏在逻辑内部而不作为一个独立的模板参数出现的。我们通过将布尔值与`void`进行比较（如检查类型是否为void），或者在编译器基于上下文的情境中创建内部函数而不是完整的独立参数集来解决前面的问题。然而这种方式虽然避免了对非用户直接参与的中间类型的直接引用，但它仍然依赖于特定的编译逻辑来根据条件启用或禁用某些功能。在设计复杂的模板时，需要权衡灵活性和清晰度之间的权衡。

#include <iostream>
#include <type_traits>

struct Color {};

// 假设 Linear 是某种类型
struct Gray {};

// 模板类定义
template <typename T, typename U>
class MyTemplate {
public:
	template <typename D = Gray> //默认
	void print() {
		if constexpr (std::is_same_v<D, Color>) {
			std::cout << "Template with T and U." << std::endl;
		}
		else {
			std::cout << "Template with T, U, and additional type D." << std::endl;
		}
	}
};

int main() {
	// 使用基本模板实例化，T = int, U = float
	MyTemplate<int, float> myTemplate1;
	myTemplate1.print();  // 输出：Template with T, U, and additional type D.

	// 使用额外的类型D，这里我们指定为Linear
	myTemplate1.print<Color>();  // 输出：Template with T and U.

	// 另一个实例化，使用不同的类型
	MyTemplate<double, char> myTemplate2;
	myTemplate2.print();  // 输出：Template with T, U, and additional type D.

	// 继续使用额外的类型
	myTemplate2.print<Gray>();  // 输出：Template with T and U.

	return 0;
}

上面程序只判断一层模版，如果判断多层模版呢？

#include <iostream>
#include <type_traits>

struct dim3
{

};

struct dim2
{

};

struct Color {};

// 假设 Linear 是某种类型
struct Gray {};

// 模板类定义
template <typename T, typename U>
class MyTemplate {
public:
	template <typename D = Gray> //默认
	void print() {
		if constexpr (std::is_same_v<D, Color> && std::is_same_v<U, dim3>) {
			std::cout << "Template with T and U." << std::endl;
		}
		else {
			std::cout << "Template with T, U, and additional type D." << std::endl;
		}
	}
};

int main() {
	// 使用基本模板实例化，T = int, U = float
	MyTemplate<int, dim3> myTemplate1;
	myTemplate1.print();  // 输出：Template with T, U, and additional type D.

	// 使用额外的类型D，这里我们指定为Linear
	myTemplate1.print<Color>();  // 输出：Template with T and U.

	// 另一个实例化，使用不同的类型
	MyTemplate<double, char> myTemplate2;
	myTemplate2.print();  // 输出：Template with T, U, and additional type D.

	// 继续使用额外的类型
	myTemplate2.print<Gray>();  // 输出：Template with T and U.


	MyTemplate<double, dim3> myTemplate3;
	myTemplate3.print<Color>();  // 输出：Template with T, U, and additional type D.

	return 0;
}

使用变参模板

另一种方式是使用变参模板。这种方法允许更灵活的参数数量和类型。下面的示例展示了如何设计可以接受不同参数数量的模板：

#include <iostream>
#include <type_traits>

// 基本模板定义
template <typename T, typename U, bool DeviceType, bool HasExtraType = false, typename... Args>
class MyTemplate;

// 特化版本，仅基于两种类型和布尔值
template <typename T, typename U, bool DeviceType>
class MyTemplate<T, U, DeviceType, false> {
public:
	void print() {
		std::cout << "Using template with two types and a bool." << std::endl;
	}
};

// 特化版本，带有额外类型参数
template <typename T, typename U, bool DeviceType, typename... Args>
class MyTemplate<T, U, DeviceType, true, Args...> {
public:
	void print() {
		std::cout << "Using template with two types, one additional type, and a bool." << std::endl;
	}
};

int main() {
	MyTemplate<int, double, true> myInstance1;
	myInstance1.print(); // 将调用第一个特化版本

	MyTemplate<int, double, true, true, char> myInstance2; // 需要明确指定有额外类型
	myInstance2.print(); // 将调用第二个特化版本

	return 0;
}

 

 功能：指定类型才能调用成员函数

  typename std::enable_if<std::is_same<D, Dim2>::value>::type 是 C++ 中一种常用的 SFINAE（Substitution Failure Is Not An Error）技术，主要用于条件性地启用或禁用模板函数。让我们逐步解析这个表达式。

逐步解析

  1. std::is_same<D, Dim2>::value：

    • std::is_same 是 C++ 标准库中的一个类型特性，它用于检查两个类型是否相同。
    • std::is_same<D, Dim2>::value 将返回一个布尔值：如果 D 是 Dim2 类型，则为 true；否则为 false。

  2. std::enable_if：

    • std::enable_if 是一个模板类，它的作用是在满足特定条件时定义类型，同时在不满足条件时不定义类型。
    • std::enable_if<Condition, T>::type 的逻辑是：
      • 如果 Condition 为 true，那么 std::enable_if 将定义一个类型 T。
      • 如果 Condition 为 false，则不定义这个类型，并导致 SFINAE（替代失败不是错误）。

  3. typename std::enable_if<std::is_same<D, Dim2>::value>::type：

    • 如果 std::is_same<D, Dim2>::value 为 true，enable_if 会定义一个类型，并通过 typename 关键字进行引用。通常，这个类型会被设为 void（默认）。
    • 如果条件不成立（即 D 不是 Dim2），那么这个类型不会被定义，导致这一重载函数在不满足的情况下被排除。

用法示例

在模板函数中使用这个技术的目的是：

  • 条件编译：使得某个特定的函数重载只有在某些情况下可用。
#include <iostream>
#include <type_traits>

struct Dim2 {};
struct Dim3 {};

class Resizer {
public:
    // 当 D 为 Dim2 时有效
    template<typename D>
    typename std::enable_if<std::is_same<D, Dim2>::value>::type
    resize() {
        std::cout << "Resizing for Dim2!" << std::endl;
    }

    // 当 D 为 Dim3 时有效
    template<typename D>
    typename std::enable_if<std::is_same<D, Dim3>::value>::type
    resize() {
        std::cout << "Resizing for Dim3!" << std::endl;
    }
};

int main() {
    Resizer resizer;
    resizer.resize<Dim2>(); // 输出: Resizing for Dim2!
    resizer.resize<Dim3>(); // 输出: Resizing for Dim3!
    // resizer.resize<int>(); // 如果取消注释，这将导致编译错误
    return 0;
}

总结

      通过 std::enable_if，可以实现特定条件下的函数重载功能。在这个例子中，resize 函数的版本只有在模板参数 D 为 Dim2 或 Dim3 时才是可用的。其他类型（如 int）将导致编译错误，而不会使程序崩溃或其他运行时错误，有效地增强了类型安全性。

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

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

相关文章

8585 栈的应用——进制转换

8585 栈的应用——进制转换

### 思路 1. **初始化栈**&#xff1a;创建一个空栈用于存储转换后的八进制数的每一位。 2. **十进制转八进制**&#xff1a;将十进制数不断除以8&#xff0c;并将余数依次入栈&#xff0c;直到商为0。 3. **输出八进制数**&#xff1a;将栈中的元素依次出栈并打印&#xff0c;…
阅读更多...
navicate连接oracle数据库probable oracle net admin error

navicate连接oracle数据库probable oracle net admin error

没用过oracle数据库 1、数据库版本19c&#xff1b; 使用dbeaver连接是没有问题的 使用navicate一直报错 解决方案&#xff1a; oracle官网下载win64的OCI环境 https://www.oracle.com/database/technologies/instant-client/winx64-64-downloads.html 下载好的压缩包直接解…
阅读更多...
Git入门学习（1）

Git入门学习（1）

Git 00.准备工作-gitee注册 今天Git的设置中需要用到gitee的注册信息&#xff0c;先自行完成注册工作&#xff0c;可以 参考笔记 或第二天视频&#xff08;10.Git远程仓库-概念和gitee使用准备&#xff09; 传送门: gitee&#xff08;码云&#xff09;:https://gitee.com/ 注…
阅读更多...
Hutool树结构工具-TreeUtil构建树形结构

Hutool树结构工具-TreeUtil构建树形结构

1 pom.xml <dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.8.26</version> </dependency> 2 核心代码 import cn.beijing.satoken.domain.ZhiweiCityArea; import cn.beijing.sa…
阅读更多...
Superset二次开发之优化Mixed Chart 混合图(柱状图+折线)

Superset二次开发之优化Mixed Chart 混合图(柱状图+折线)

背景 基于Mixed Chart（柱状图+折线）作图，显示 某维度A Top10 + 其他 数据，接口返回了值为 undefined 的某维度A 数据，前端渲染成 某维度A 值为 0 此图表存在的问题： 图表控件编辑页面，即便数据集正常查询出 Top10 + ‘其他’ 数据，但是堆积图表渲染时，返回了 值为 0…
阅读更多...
HarmonyOS ArkTS 用户首选项的开发及测试

HarmonyOS ArkTS 用户首选项的开发及测试

本节以一个“账本”为例&#xff0c;使用首选项的相关接口实现了对账单的增、删、改、查操作&#xff0c;并使用自动化测试框架arkxtest来对应用进行自动化测试。 为了演示该功能&#xff0c;创建一个名为“ArkTSPreferences”的应用。应用源码可以在文末《跟老卫学HarmonyOS开…
阅读更多...
恢复已删除文件的可行方法，如何恢复已删除的文件

恢复已删除文件的可行方法，如何恢复已删除的文件

在清理 PC 或优化存储设备时无意中删除重要文件是一种常见的人为错误。不可否认&#xff0c;在批量删除文件时&#xff0c;您通常会一起删除垃圾文件和重要文件。您后来意识到一堆文件或文件中缺少一个重要的文档或文件。在这种情况下&#xff0c;您唯一的选择是寻找恢复已删除…
阅读更多...
优思学院｜如何通过六西格玛方法优化流程，减少90%的浪费？

优思学院｜如何通过六西格玛方法优化流程，减少90%的浪费？

随着竞争压力的增加和对更快结果的需求&#xff0c;越来越多的企业开始依赖精益六西格玛来优化流程&#xff0c;减少浪费。精益六西格玛不仅改变了制造业&#xff0c;也影响了几乎所有行业的业务运营&#xff0c;提升了效率&#xff0c;消除了低效环节。这里优思学院和大家探讨…
阅读更多...
sheng的学习笔记-AI-强化学习（Reinforcement Learning, RL）

sheng的学习笔记-AI-强化学习（Reinforcement Learning, RL）

AI目录&#xff1a;sheng的学习笔记-AI目录-CSDN博客 基础知识 什么是强化学习 强化学习&#xff08;Reinforcement Learning, RL&#xff09;&#xff0c;又称再励学习、评价学习或增强学习&#xff0c;是机器学习的范式和方法论之一&#xff0c;用于描述和解决智能体&#…
阅读更多...
电机设计及电机仿真APP系列之—高速永磁同步电机仿真APP

电机设计及电机仿真APP系列之—高速永磁同步电机仿真APP

电机的各种工作状态和参数变化。用户可通过调整仿真参数&#xff0c;快速得到电机的响应和性能参数&#xff0c;从而进行针对性的优化和改进。借助仿真APP&#xff0c;可大大减少电机设计迭代次数和成本&#xff0c;提高测试效率和准确性。 小编整理了10款不同类型的电机仿真A…
阅读更多...
掌握顶会流量密码！“Mamba+CNN”双热点组合！轻松找到创新点！

掌握顶会流量密码！“Mamba+CNN”双热点组合！轻松找到创新点！

传统视觉模型在处理大规模或高分辨率图像时存在一定限制。然而Mamba与CNN相结合&#xff0c;在处理序列数据和图像数据时有着显著的优势&#xff0c;并且能够有效提升模型计算效率和准确率。 这种结合可以让Mamba在处理长序列数据时既能够捕捉到序列中的时间依赖关系&#xff…
阅读更多...
springboot整合springbatch和xxljob实现定时数据同步（完整代码）

springboot整合springbatch和xxljob实现定时数据同步（完整代码）

springboot整合springbatch和xxljob实现定时数据同步&#xff08;完整代码&#xff09; 前言&#xff1a;公司一些老项目的定时任务使用spring自带的调度器来完成数据同步的&#xff0c;久而久之带来很多的不方便。首先没办法快速定位监控定时任务的执行情况&#xff0c;其次就…
阅读更多...
c++11右值引用和移动语义

c++11右值引用和移动语义

一.左值引用和右值引用 什么是左值引用&#xff0c;什么是右值引用 左值是一个表示数据的表达式&#xff08;变量名解引用的指针&#xff09;&#xff0c;我们可以获取到它的地址&#xff0c;可以对它赋值&#xff0c;左值可以出现在符号的左边。使用const修饰后&#xff0c;…
阅读更多...
python检测keycloak证书连接报错问题

python检测keycloak证书连接报错问题

最近一直被keycloak的证书问题困扰了很久&#xff0c;老是提示ssl安全连接&#xff0c;由于不会java,只好硬着头皮用python测试。 我这里的证书是自己签注的证书&#xff0c;导入系统的是CA根证书。 from keycloak import KeycloakOpenID# 1. 配置 Keycloak 客户端 keycloak_o…
阅读更多...
电子画册3D翻页电子版是如何制作

电子画册3D翻页电子版是如何制作

​随着科技的发展&#xff0c;传统的纸质画册逐渐被电子画册所取代。电子画册3D翻页电子版以其独特的交互方式和丰富的视觉体验&#xff0c;受到了越来越多人的喜爱。让我来教你怎么制作吧。 1.要制作电子杂志,首先需要选择一款适合自己的软件。比如FLBOOK在线制作电子杂志平台…
阅读更多...
信息收集常用指令

信息收集常用指令

目的 本文主要是记录一些在信息搜集时&#xff0c;常用的提高搜索效率的命令。 后续会继续记录一些用到的更多指令和方法&#xff0c;慢慢更新。 1、inurl “inurl:xxx”是指查找url中包含xxx的网页。 URL&#xff1a;统一资源定位符。统一资源定位系统。可以说包含域名&am…
阅读更多...
ThreaLocal

ThreaLocal

1.概述 ThreadLoca称线程局部变量&#xff0c;用于在线程中保存数据&#xff0c;保存的数据仅属于当前线程(即对其他线程而言&#xff0c;该变量是当前线程独有的变量) threadLocal利用Thread中的ThreadLocalMap来进行数据存储 2.常用方法 存储数据至当前线程ThreadLocalMap中…
阅读更多...
无监督神经组合优化的扩散模型框架

无监督神经组合优化的扩散模型框架

文章目录 Abstract1. Introduction2. Problem Description2.1 无监督神经组合优化3. Neural Probabilistic Optimization Objective for Approximate Likelihood Models3.1 具有联合变分上界的训练扩散模型Abstract 从离散集合的不可处理分布中进行采样，而不依赖相应的训练数据…
阅读更多...
OpenAI o1解决了Quiet-STaR的挑战吗？（下）

OpenAI o1解决了Quiet-STaR的挑战吗？（下）

随着OpenAI o1近期的发布&#xff0c;业界讨论o1关联论文最多之一可能是早前这篇斯坦福大学和Notbad AI Inc的研究人员开发的Quiet-STaR&#xff0c;即让AI学会先安静的“思考”再“说话” &#xff0c;回想自己一年前对于这一领域的思考和探索&#xff0c;当初也将这篇论文进行…
阅读更多...
初学者蒙语学习，使用什么翻译软件学习更快？

初学者蒙语学习，使用什么翻译软件学习更快？

为了加快蒙古语的学习&#xff0c;初学者应该从基础语法和词汇入手&#xff0c;利用语言学习应用进行系统学习&#xff0c;并通过音频和视频材料提高听力。语言交换和参加课程可以提供实践机会&#xff0c;而使用闪卡和文化沉浸有助于记忆词汇和理解语言背景。定期复习和设定学…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023