#include <iostream>
using namespace std;
int main() {
cout << "2 << 1 == " << (0b010 << 1); // 0b100
return 0;
}#include <iostream>
using namespace std;
struct Foo {
Foo& operator<<(int x) {
cout << "Integer: " << x << '\n';
return *this;
}
Foo& operator<<(const char* str) {
cout << "String: " << str << '\n';
return *this;
}
};
int main() {
Foo foo;
foo << 3; // Integer: 3
foo.operator<<("Hello world"); // String: Hello world
return 0;
}
_11111__1_
#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);