#include <vector>
const int voxel_size = 16;
std::vector<short> get_voxels_from_chunk(short (*voxels)[voxel_size][voxel_size][voxel_size], int world_length, int chunk_size_x, int chunk_size_y, int chunk_size_z, int chunk_id) {
std::vector<short> result;
int chunk_count_x = world_length / chunk_size_x;
int chunk_count_y = world_length / chunk_size_y;
int chunk_count_z = world_length / chunk_size_z;
int chunk_index_x = chunk_id % chunk_count_x;
int chunk_index_y = (chunk_id / chunk_count_x) % chunk_count_y;
int chunk_index_z = chunk_id / (chunk_count_x * chunk_count_y);
int x_offset = chunk_index_x * chunk_size_x;
int y_offset = chunk_index_y * chunk_size_y;
int z_offset = chunk_index_z * chunk_size_z;
for (int i = x_offset; i < x_offset + chunk_size_x; i++){
for (int ii = y_offset; ii < y_offset + chunk_size_y; ii++){
for (int iii = z_offset; iii < z_offset + chunk_size_z; iii++){
result.push_back(*(*(*(voxels + i) + ii) + iii));
}
}
}
return result;
}
int main() {
short voxels[voxel_size][voxel_size][voxel_size]; // пример массива вокселей
int world_length = voxel_size;
int chunk_size_x = 4;
int chunk_size_y = 8;
int chunk_size_z = 8;
int chunk_id = 3; // пример id чанка
std::vector<short> chunk_voxels = get_voxels_from_chunk(&voxels, world_length, chunk_size_x, chunk_size_y, chunk_size_z, chunk_id);
// обработка chunk_voxels
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
int main(int argc, char** argv)
{
int fin = open(argv[1], O_RDONLY);
struct stat finfo = {0};
fstat(fin, &finfo);
char *map = mmap(0, finfo.st_size, PROT_READ, MAP_SHARED, fin, 0);
char src[4] = {0};
char dst[4] = {0};
int cost;
int i;
int off = 0;
while (off < finfo.st_size)
{
memcpy(src, map + off, 3);
memcpy(dst, map + off + 4, 3);
i = 0;
cost = 0;
while (map[off + 8 + i] != 10) {
cost = cost * 10 + map[off + 8 + i] - 48;
++i;
};
off += 9 + i;
};
munmap(map, finfo.st_size);
close(fin);
return EXIT_SUCCESS;
}
Больших отличий я не заметил
while (num_bor_1 <= num_bor_2)
{
if ((num_bor_1 % 2) != 1)
{
num_bor_1++;
}
}do
{
num_bor_1++;
} while (num_bor_1 < num_bor_2);#include <stdlib.h>
int main()
{
system("installer.exe");
return 0;
}#include <windows.h>
int main()
{
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi));
// Запускаем процесс
CreateProcess("installer.exe", NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
// Ожидаем завершения процесса
WaitForSingleObject(pi.hProcess, INFINITE);
// Закрываем дескрипторы процесса и потока
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
return 0;
}
$time = date("H", time());
$os = [
'14' => '1',
'15' => '2',
'16' => '3',
'17' => '4',
];
$val = $os[$time] ?: 'no value';
echo $time . "<br><br>" . $val;Как скрыть адрес вызываемой функции в C++?в контексте обфускации, подразумевается что по декомпилированному исходному коду должно быть не ясно, какой именно метод будет вызываться (т.е. для анализа требуется отладка, что сложнее/дороже), значит хранить адреса методов нужно в каких то переменных, например массивах, а выбор следующего вызываемого метода делать на основе каких то вычислений по коду.
// определяем класс
class MyClass
{
public:
void myFunA(){std::cout<<"A";};
void myFunB(){std::cout<<"B";};
};std::function<void(MyClass*)> functions[]={&MyClass::myFunA,&MyClass::myFunB};MyClass obj;
functions[x](&obj);
Console.WriteLine("Введите x: ");
var x = double.Parse(Console.ReadLine());
Console.WriteLine("Введите a: ");
var a = double.Parse(Console.ReadLine());
Console.WriteLine("Введите n: ");
var n = double.Parse(Console.ReadLine());
var result = Solution.Calculate(x, a, n);
Console.WriteLine($"Ответ: {result}");
public static class Solution {
public static double Calculate(double x, double a, double n) =>
Math.Pow(Math.Tan(Math.Exp(a+2)), 1.0/3.0) *
Math.Pow(
Math.Pow(a*x*n, 3) *
Math.Sqrt(1.0 / Math.Tan(Math.Pow(x, Math.Exp(a+2)))),
3);
}public static class Solution {
public static double Calculate(double x, double a, double n) =>
// По заданию мы тут берём корень 3-ей степени и сразу возводим в 3ю степень. Убираем их, тк эти две операции отменяют друг друга.
Math.Tan(Math.Exp(a+2)) *
Math.Pow(
Math.Pow(a*x*n, 3) *
//котангенс(x) = 1/тангенс(x)
Math.Sqrt(1.0 / Math.Tan(Math.Pow(x, Math.Exp(a+2)))),
3);
}
не спрашивайте зачем мне это нужнодействительно. C++ ABI -- это боль, сильная боль. Даже разработчики компиляторов страдают от неё. Если вам уж прям так важно поковыряться в его кишках, то изучайте исходники LLVM и спецификацию стандарта ABI. А если нет, то возьмите OpenCV C API и не выносите себе голову.
но описан как функцияА как он должен быть описан, как сферический код в вакууме?
чем отличается от обычных деструкторовСтандарт определяет деструкторы:
что на самом деле означает `vbase destructor`, в каких случаях он вызываетсяЕсть предположение, что это имя экспортируемого
complete object destructor для класса, базовым классом которого является класс с виртуальным деструктором. То есть, он выполняет часть процесса цепочки деструкторов, которая помимо вызова base object destructor, вызывает также все деструкторы для всех базовых виртуальных классов. Но при этом ещё не вызван deleting destructor, который собственно вызывает operator delete. Т.е. получается, что complete object destructorпо включённому в него списку действий, как бы "наследуется" от base object destructor. В свою очередь, deleting destructor "наследуется" от complete object destructor.Предполагаю, что вызывается автоматически в замыканиях. Но что на самом деле означает `default constructor closure'Для чего он может вызываться в замыканиях, просто чтоб было?
Не работает деструктор
a = c_char_p(f'{getcwd()}\\file.txt'.encode())
b = c_char_p(b'Help me pls')