例如，有这样一段代码：
void obj::foo() {
... // some operations
std::lock_guard lock{mut_};
... // some operations and initialization ariables
lock.unlock();
... // other operations
}
如您所见，关键部分位于函数的中间，并用互斥锁隔离。但是，我在某处读到，如果它们不相互依赖，编译器可以自行决定对操作顺序进行改组，所以我想澄清一下：是否保证初始化lock和调用之间的所有内容都lock.unlock()将受到互斥锁的保护？或者编译器可以决定这些调用之间的某些操作可以在锁之外的其他地方执行？
我决定看看第 20 个标准中引入了哪些更改，而第一个更改让我感到困惑：模块。很长一段时间以来，我都试图理解为什么要引入它们以及它们应该如何工作（我不是在谈论语法和用法示例）。
据我了解，模块可以作为将代码拆分为头文件和源文件的替代方法！这种分裂不仅发生了。Created 被迫这样做是为了使编译器单程通过。编译器在预处理文件时，用这些包含的内容替换所有包含指令，这是一个简单的操作，只需要您指定在哪里查找这些包含（如果它们不在标准位置之一中）。但是编译器如何处理模块呢？在这里它符合模块导入指令——它的动作？这不是文件名，如果尚未遇到带有此模块的文件，它不知道在哪里寻找它。它是否应该通过资源来寻找该模块的导出位置？搁置当前文件并开始处理其他文件，直到遇到所需的模块？模块如何影响编译器性能？
遇到了这个问题：我在vim（8版）中直接使用formatters来格式化代码，当然是同步调用的，但是如果文件很大，格式化需要很长时间，我马上调用另一个命令（例如，在保存时），然后发生了一件非常不愉快的事情 - 输入命令的栏向上移动，因此占据 2 行，但没有重绘带有缓冲区的窗口。结果，窗口内容无效，当光标上下移动时，变为有效。屏幕截图显示了这一点：
这完全可以预防/解决吗？
例如，我有一个python充当配置文件的脚本。也就是说，在其中声明了一些变量，调用函数来初始化其中的一些。那么：如何在不编辑配置本身的情况下获取其中一个变量的值？
例如，有这个模板：
template <typename ValueType, template <typename> typename Container>
void foo(const Container<ValueType> &container) {
std::cout << "hello" << std::endl;
}
其中一个模板参数本身就是一个模板。据我所知，这是一个完全有效的构造。现在让我们做一个小例子：
// main.cpp
#include <cstdlib>
#include <vector>
template <typename ValueType, template <typename> typename Container>
void foo(const Container<ValueType> &container) {
}
int main() {
std::vector<int> tmp;
foo(tmp);
return EXIT_SUCCESS;
}
此示例编译没有问题gcc-8.3.0，但没有编译clang-9.0.1，会引发以下错误：
candidate template ignored: substitution failure [with ValueType = int]:
template template argument has different template parameters than its
corresponding template template parameter
void foo(const Container<ValueType> &container) {
^
为什么会这样？这是一个错误吗？
根据 Delaunay 三角剖分的定义：
对平面上给定的一组点 S 进行三角剖分，其中对于任何三角形，除了作为其顶点的点之外，来自 S 的所有点都位于三角形周围所描述的圆之外
类似多边形的正确三角剖分（Delaunay！）是否正确：{{1, 1}, {1, 100}, {2, 100}, {2, 1}}
不可能的？毕竟，从任何生成的三角形绘制的圆将包含多边形（矩形）的所有点。
例如，我有一个带 vertices 的三角形A B C。这些顶点中的每一个都与某个值相关联（我们从该值的类型中抽象出来 - 主要是它受到线性插值的影响）：x, y, z- 分别用于每个顶点。还有一些点D位于三角形内部或三角形的一侧。如何尽可能简单地找到该点的值（以更少的步骤）D？
该top命令的输出显示一列Virt- 虚拟内存消耗，但我不太明白虚拟内存是什么类型，为什么它的数量超过了实际消耗的 RAM 数量？Tobish，我有一个应用程序（微服务），它在运行时会消耗：
cuda）同时在主机上：
实际上：这个数字在 14.1G 中是什么意思？为什么它是最大数量的特工（特别是考虑到它swap失踪了）？
据我所知，对于с++（由于历史原因）中的功能，以下身份是正确的：
foo == &foo;
Tobish 指向函数的指针与函数相同，反之亦然。但是，这些值有不同的类型：
std::is_same<decltype(foo), decltype(&foo)>::value == false;
为什么种类不同？它们是什么？
我们都知道编译器会丢弃未使用的变量，如i下面的变量：
int main() {
int a = 10;
int i = 15;
std::cout << a << std::endl;
return 0;
}
我还对编译器是否可以在变量离开作用域之前调用析构函数感兴趣（例如，在它最后一次使用之后）。特别感兴趣的是以下情况：
int foo() {
static std::mutex mutex;
std::lock_guard<std::mutex>{mutex};
... some code ...
return 0;
}
Tobish：在这种情况下，是否有可能在函数退出之前释放互斥锁？
我阅读了一篇关于Habréс++的文章，关于在使用子解释器的多线程应用程序中使用 Python 。同时，如文章所述，这允许您提供“纯多线程”，即子解释器不会全局锁定GIL（我为重言式道歉），而是并行工作。总的来说，我决定尝试编写以下代码：
// main.cpp
#include <boost/python.hpp>
#include <cstdlib>
#include <iostream>
#include <list>
#include <mutex>
#include <thread>
#include <unistd.h>
#include <unordered_map>
class PyMainThread final {
public:
PyMainThread()
: mainThreadState_{nullptr} {
::Py_Initialize();
::PyEval_InitThreads();
mainGIL_ = ::PyGILState_Ensure();
mainThreadState_ = ::PyEval_SaveThread();
}
~PyMainThread() {
::PyEval_RestoreThread(mainThreadState_);
::PyGILState_Release(mainGIL_);
}
PyMainThread(const PyMainThread &) = delete;
PyMainThread &operator=(const PyMainThread &) = delete;
private:
::PyGILState_STATE mainGIL_;
::PyThreadState * mainThreadState_;
};
static std::mutex mutex;
class PySubThread final {
public:
PySubThread()
: mainThreadState_{nullptr}
, subThreadState_{nullptr}
, newInterpreterThread_{nullptr} {
std::lock_guard<std::mutex> lock(mutex);
mainGIL_ = ::PyGILState_Ensure();
mainThreadState_ = ::PyThreadState_Get();
newInterpreterThread_ = ::Py_NewInterpreter();
::PyThreadState_Swap(newInterpreterThread_);
subThreadState_ = ::PyEval_SaveThread();
subGIL_ = ::PyGILState_Ensure();
}
~PySubThread() {
std::lock_guard<std::mutex> lock(mutex);
::PyGILState_Release(subGIL_);
::PyEval_RestoreThread(subThreadState_);
::Py_EndInterpreter(newInterpreterThread_);
::PyThreadState_Swap(mainThreadState_);
::PyGILState_Release(mainGIL_);
}
PySubThread(const PySubThread &) = delete;
PySubThread &operator=(const PySubThread &) = delete;
private:
::PyGILState_STATE mainGIL_;
::PyGILState_STATE subGIL_;
::PyThreadState *mainThreadState_;
::PyThreadState *subThreadState_;
::PyThreadState *newInterpreterThread_;
};
std::unordered_map<std::thread::id, std::unique_ptr<PySubThread>> pyThreads;
std::mutex pyM;
void foo(const std::string &pythonFile, int iterationCount) {
volatile PySubThread subThread;
for (int i = 0; i < iterationCount; ++i) {
try {
// std::this_thread::sleep_for(std::chrono::milliseconds{1000});
boost::python::object import = boost::python::import("__main__");
boost::python::object result =
boost::python::exec_file(pythonFile.c_str(), import.attr("__dict__"));
} catch (boost::python::error_already_set &) {
::PyErr_Print();
}
}
}
int main(int argc, char *argv[]) {
if (argc < 4) {
std::cerr << "you must set script, threads and count of iterations"
<< std::endl;
return EXIT_FAILURE;
}
volatile PyMainThread mainThread;
std::list<std::thread> threads;
for (int i = 0; i < std::atoi(argv[2]); ++i) {
threads.emplace_back(foo, argv[1], argv[3]);
}
for (auto &i : threads) {
i.join();
}
return EXIT_SUCCESS;
}
这是一个在代码中抽搐的python脚本：
import time
def caculate(a, b):
return a + b
def main():
print("sleep 2 seconds ...")
time.sleep(2)
print("... and calculate")
return caculate(-10, 20)
main()
# cmake
cmake_minimum_required(VERSION 3.5)
project(tmp)
find_package(Boost COMPONENTS python37 REQUIRED)
find_package(Python3 COMPONENTS Development REQUIRED)
find_package(Threads REQUIRED)
add_executable(${PROJECT_NAME} main.cpp)
target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_11)
target_link_libraries(${PROJECT_NAME} PRIVATE
Boost::boost
${Python3_LIBRARIES}
${Boost_LIBRARIES}
Threads::Threads
)
target_include_directories(${PROJECT_NAME} PRIVATE ${Python3_INCLUDE_DIRS})
当在多个线程中运行时，一切正常，如文章中所述，但是！注意с++代码中的第 88 行。此行将 Python 子解释器线程暂停一秒钟。如果取消注释，程序将挂起并且永远不会完成。同时，无法检测到程序停止的地方（恕我直言，这是在其中一个子解释器的构造函数中获取 GIL），使用调试器，因为当我逐步执行程序时，它正常结束.
基本上我有两个问题：
1）文章中所说的是否正确？
2) 确保在代码中并行执行 Python 脚本（无锁）如何正确（如果可能）c++？
是否有保证的动作顺序：
for (int i = 0, j = 0; i < size; ++i, j = i * coaf) {
Tobish，是否保证++i在计算之前先计算j = i * coaf？
例如，我有两个矩阵：一个图像和图像的每个像素需要乘以的系数。矩阵具有相同的维度，但类型不同：图像CV_8UC3和系数CV_32FC1。由于类型不匹配，该函数cv::multiply在此处不起作用。你当然可以循环乘法，但我认为应该有比这更好的解决方案。
例如，我有一个这样的函数调用：
std::unique_ptr tmp{new MyClassWithNameFunction};
foo(tmp->name(), std::move(tmp));
是否保证方法调用name()将首先发生？
有一个矩阵（比方说3x3）用于变换二维点的某个数组（比方说std::vector<Point>）。如何通过手段正确地做到这一点opencv？我通过矩阵乘法找到了一个变体operator*（为此我们转换vector为Map），但是当我尝试将结果转换为时cv::Mat出现错误：
put_asset: /home/levkovitch/Public/tmp/put_assets/main.cpp:119: cv::Rect operator*(const cv::Mat&, const Rect&): Assertion `matrix.elemSize() == 3' failed.
PSS一般来说，一个点数组就是一个矩形的顶点cv::Rect
例如，有一个具有模板成员函数的类get不专门处理该类的标头。在另一个文件中（cpp在这个类声明之外），我创建了这个模板的两个特化，稍后将在代码中使用。所以，编译后，我得到一个很奇怪的结果：在调试版本（优化-O0）中，调用模板成员时，我调用了专门的函数，而在发布版本（优化）-O3中，调用了“空”的......
为什么？
这是一个例子：
结构体：
.
├── build.cmake
├── CMakeLists.txt
├── main.cpp
├── TemplateClass.hpp
└── utils.cpp
编码：
# cmake
cmake_minimum_required(VERSION 3.12)
project(template)
include(build.cmake)
set(PROJECT_SRC
main.cpp
utils.cpp
)
add_executable(${PROJECT_NAME} ${PROJECT_SRC})
# build.cmake
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
if(NOT CMAKE_BUILD_TYPE)
SET(CMAKE_BUILD_TYPE Release)
endif(NOT CMAKE_BUILD_TYPE)
if(NOT DEFINED BUILD_SHARED_LIBS)
set(BUILD_SHARED_LIBS ON)
endif()
if(${CMAKE_BUILD_TYPE} STREQUAL Debug)
enable_testing()
include(CTest)
endif()
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
else()
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wall")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Wshadow -Wnon-virtual-dtor -pedantic -g -O0")
endif()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/lib")
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/lib")
option(leak_check "set leak_check" 0)
option(profiling "set profiling" 0)
option(thread_check "set thread_check" 0)
if(${CMAKE_BUILD_TYPE} STREQUAL Debug AND leak_check)
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fno-omit-frame-pointer")
endif()
if(${CMAKE_BUILD_TYPE} STREQUAL Debug AND thread_check)
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=thread")
endif()
if(${CMAKE_BUILD_TYPE} STREQUAL Debug AND profiling)
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -pg")
set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -pg")
set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} -pg")
set(CMAKE_STATIC_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} -pg")
endif()
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
endif()
message(STATUS "buid type " ${CMAKE_BUILD_TYPE})
message(STATUS "Project " ${PROJECT_NAME})
message(STATUS "c compiler " ${CMAKE_C_COMPILER})
message(STATUS "cxx compiler " ${CMAKE_CXX_COMPILER})
message(STATUS "build tests " ${BUILD_TESTING})
message(STATUS "build shared " ${BUILD_SHARED_LIBS})
message(STATUS "leak sanitizer " ${leak_check})
message(STATUS "thread sanitizer " ${thread_check})
message(STATUS "profiling " ${profiling})
// main.cpp
#include "TemplateClass.hpp"
#include <cstdlib>
#include <iostream>
int main(int argc, char *argv[]) {
(void)argc;
(void)argv;
TemplateClass a{"string", 0.5};
std::cout << "first: " << a.get<std::string>() << std::endl;;
std::cout << "second: " << a.get<double>() << std::endl;;
return EXIT_SUCCESS;
}
// TemplateClass.hpp
#pragma once
#include <string>
class TemplateClass {
public:
template <typename T>
T get() const {
return T{};
}
std::string string_;
double double_;
};
// utils.cpp
#include "TemplateClass.hpp"
template<>
double TemplateClass::get<double>() const {
return double_;
}
template<>
std::string TemplateClass::get<std::string>() const {
return string_;
}
PS恕我直言，我不喜欢类声明之外的模板专业化，但我必须使用它（意思是：没有声明的专业化，如示例所示）
例如，我有一个 lua 脚本：
return {
version = 1.0
}
我在 C 代码中加载：
if (!luaL_loadfile(state, argv[1]) && !lua_pcall(state, 0, 0, 0)) {
如何访问该表？有类似get_globaland的功能get_local，但在这种情况下它们不适合（出于明显的原因）。最初，我认为在启动时lua_pcall我应该立即将返回的表放入堆栈，但我错了。
我有一个图像 ( png)，其中包含我想要拆分并加载到单独纹理中的精灵。怎么做才对？。例如，我有一个png600x300 的尺寸，我想将其用作两个 300x300 的纹理。目前我只是完全下载
glActiveTexture(GL_TEXTURE7);
glGenTextures(1, &glTexture_);
glBindTexture(GL_TEXTURE_2D, glTexture_);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_RGBA,
pictureSize.width(),
pictureSize.height(),
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
fromRGBA32.pixels());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
并且已经在我共享的着色器中，但是当我们可以组合多个纹理然后确定要在着色器中采用哪个纹理时，我想使用创新es 3（传递一个变量比传递一个确定正方形的二维坐标更好）需要）。