#if defined(_WIN32)
#define CAPI_EXPORT __declspec(dllexport)
#else
#define CAPI_EXPORT __attribute__((visibility("default")))
#endif // _WIN32

// header.h
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
CAPI_EXPORT void printSomething();

#ifdef __cplusplus
}
#endif // __cplusplus

// 伪代码，没有多态的情况
void pressPlay(Device* device) {
    if (device->type == TV) {
        ((TV*)device)->playShow();
    } else if (device->type == BluRayPlayer) {
        ((BluRayPlayer*)device)->playDisc();
    } else if (device->type == SoundSystem) {
        ((SoundSystem*)device)->playMusic();
    }
    // 如果新增一个设备，比如 Projector（投影仪）
    // 你就必须回来修改这个函数！
    else if (device->type == Projector) {
        ((Projector*)device)->startProjection();
    }
}

decltype(expression) variableName;

// 推理参数类型
int x = 0;
int& y = x;

decltype(x) a; // int类型
decltype(y) b = a; // int& 类型

decltype((x)) c = x; // int& 类型，因为(x)是左值表达式

decltype(x*y) d = x; // int 类型，x*y为右值表达式，所以是右值类型。

// 推理模板函数返回值
template<typename T0, typename T1>
auto test(T0 a, T1 b) -> decltype(a * b) {
	...
}

// 泛型函数中，可以用来定义复杂类型或表达式的类型，从而使代码更加灵活和通用。
template<typename Container>
auto accessElement(Container& container, size_t index) -> decltype(container[index]) {
	return container[index];
}

#include <iostream>
// 首先定义终止函数（也就是参数为空的时候的函数）
void printInternal() {
	std::cout << std::endl;
}
// 然后定义解包函数
template<typename First, typename... Rest>
void printInternal(const First& first, const Rest&... rest) {
	std::cout << first << " ";
	printInternal(rest...);
}

// 定义入口函数
template<typename... Args>
void printUnlimited(const Args&... args) {
	printInternal(args...);
}

// 函数参数转发
template<typename Func, typename... Args>
auto invoke(Func&& func, Args&&... args) -> decltype(std::forward<Func>(func)(std::forward<Args>(args)...)) {
	return std::forward<Func>(func)(std::forward<Args>(args)...);
}

// 示例 模板中&&表示转发引用，不论传递给模板的是左值/右值，都能保持其类型。
template<typename T>
void target(T&& arg) {
	std::cout << "Processing argument: " << arg << std::endl;
}

template<typename T>
void wrapper(T&& arg) {
	target(std::forward<T>(arg));
}

int main () {
	int x = 10;
	wrapper(x);  // 传递左值 x
	wrapper(20); // 传递右值 20
	return 0;
}

// 声明时直接初始化，使用`=`
class TestClass {
private:
	std::string str = "default";
...
};

// 声明时直接初始化，使用`{}`，这种初始化方式是推荐的方式，称为 统一初始化 语法（Uniform Initialization Syntax）
class TestClass {
private:
	std::string std{"default"};
};

// 构造函数列表初始化，使用`()`
class TestClass {
private:
	std::string str;
public:
	TestClass(): str("default") {}
};
// 构造函数列表初始化，使用`{}`
class TestClass {
private:
	std::string str;
public:
	TestClass(): str{"default"} {}
};

// 构造函数内部初始化，这个就不用讲了，直接省略吧
class TestClass {
private:
	std::string str;
public:
	TestClass() {
		str = "default";
	}
};

// android_aosp/system/core/libcutils/include/cutils/native_handle.h:39
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wzero-length-array"
#endif
    int data[0];        /* numFds + numInts ints */
#if defined(__clang__)
#pragma clang diagnostic pop
#endif

# 举个例子我现在ubuntu上有GNU9 版本的编译器，但是我的工程需要用GNU7.5

# 先安装GNU7.5的gcc
sudo apt-get install gcc-7 g++-7

# 随后使用 update-alternateives 更新默认版本
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 70
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 70

# 或者通过环境变量指定
CC=gcc-7 CXX=g++-7 cmake ..
cmake -DCMAKE_C_COMPILER=gcc-7 -DCMAKE_CXX_COMPILER=g++-7 ..

c++: error:  -flto: No such file or directory

# 

set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}   -fvisibility=hidden")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fvisibility=hidden")
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}   -fvisibility-inlines-hidden")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fvisibility-inlines-hidden")

#if defined(_WIN32) || defined(_WIN64)
// Windows platform
#elif defined(__linux__)
// Linux platform
#elif defined(__ANDROID__)
// Android platform
#elif defined(__APPLE__) && defined(__MACH__)
#if TARGET_OS_IOS
// ios platform
#elif TARGET_OS_MAC
// macOS platform
#endif
#endif

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer -g")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer -g")

# Android Native端，使用AddressSanitizer导出的日志通常是 .so+偏移
# 如果要得到实际代码位置需要利用addr2line
addr2line -e yourlib.so <偏移>

# 如果要批量得到可以写脚本

# Eg：我现在有两个库libCNamaSDK.so和libfuai.so
# 其中link关系是libCNamaSDK.so <-- libfuai.so
# 现在我想修改库名，并且保证链接的时候使用新名称不会出问题
# libCNamaSDK.so -> libCNamaSDK_Camera.so
# libfuai.so -> libfuai_Camera.so

# 使用patchelf指令
# 1. 修改库名
mv libCNamaSDK.so libCNamaSDK_Camera.so
mv libfuai.so libfuai_Camera.so
# 2. 修改elf信息
# 2.1 修改每个库的soname
# patchelf --set-soname <新SONAME> <目标文件>
patchelf --set-soname libCNamaSDK_Camera.so libCNamaSDK_Camera.so
patchelf --set-soname libfuai_Camera.so libfuai_Camera.so

# 2.2 修改链接信息
# patchelf --replace-needed <旧库名称> <新库名称> <目标文件>
patchelf --replace-needed libfuai.so libfuai_Camera.so libCNamaSDK_Camera.so

LD_LIBRARY_PATH=<your_libs_path> ldd <absolute_path_to_your lib>

#include <iostream>
#include <memory>
#include <mutex>
#include <vector>

class Engine {
public:
  enum class MemoryPolicy { PerformanceEfficient = 0, MemoryEfficient = 1 };
  static void setMemoryPolicy(MemoryPolicy policy) { _policy = policy; }
  static std::shared_ptr<Engine> createInstance() {
    std::shared_ptr<Engine> instance = nullptr;

    std::lock_guard<std::mutex> look(_mtx);
    if (_w_ptr.lock() == nullptr) {
      // Get no engine, init the engine.
      instance = std::shared_ptr<Engine>(new Engine);
      _w_ptr = instance; // assign instance to weak_ptr.

      if (_policy == MemoryPolicy::PerformanceEfficient) {
        // PerformanceEfficient
        // Decrease the ref count of instance until program exit or called
        // Engine::releaseInstance()
        _ptr = instance;
      } else {
        // MemoryEfficient
        // Directly release the instance if no outside reference.
        _ptr = nullptr;
      }
      // Register the release function to be called at program exit (when main
      // returns) to avoid issues caused by the release order of static 
      // variables in libOpenCL.so.
	  std::atexit(Engine::releaseInstance);
    } else {
      // Memory effecient, remove the reference of _ptr.
      instance = _w_ptr.lock();
    }

    return instance;
  }
  static void releaseInstance() {
    std::lock_guard<std::mutex> lock(_mtx);
    _ptr = nullptr;
  }
  static void printRefCount() {
    std::lock_guard<std::mutex> lock(_mtx);
    std::cout << "Current reference: " << _w_ptr.use_count() << ", "
              << _w_ptr.lock() << std::endl;
  }
  ~Engine() {
    // 析构函数只会在智能指针引用计数为零的时候调用，所以_w_ptr.use_count()必须为0.
    std::cout << "Release the engine, " << _w_ptr.use_count() << std::endl;
  }

private:
  Engine() { std::cout << "Init the engine. " << std::endl; }
  static std::mutex _mtx; // mutex
  static std::shared_ptr<Engine> _ptr;
  static std::weak_ptr<Engine> _w_ptr;
  static MemoryPolicy _policy;
};

std::weak_ptr<Engine> Engine::_w_ptr;
std::shared_ptr<Engine> Engine::_ptr = nullptr;
std::mutex Engine::_mtx;
Engine::MemoryPolicy Engine::_policy =
    Engine::MemoryPolicy::PerformanceEfficient;

int main() {
  Engine::setMemoryPolicy(Engine::MemoryPolicy::PerformanceEfficient);
  {
    std::shared_ptr<Engine> engine0 = Engine::createInstance();
    Engine::printRefCount();
  }

  {
    std::shared_ptr<Engine> engine1 = Engine::createInstance();
    Engine::printRefCount();
  }

  {
    std::shared_ptr<Engine> engine2 = Engine::createInstance();
    Engine::printRefCount();
  }

  Engine::printRefCount();
  return 0;
}

#include <chrono>
#include <iostream>
// 直接计时
auto start = std::chrono::high_resolution_clock::now()
...
auto end = std::chrono::high_resolution_clock::now();

auto duration = std::chrono::duration_cast<sstd::chrono::milliseconds>(end - start);
std::cout << "Timer: " << duration.count() << std::endl;

// 析构函数+宏
class _TimerInternal {
public:
  _TimerInternal(const std::string &timer_name)
      : _name(timer_name), _start(std::chrono::high_resolution_clock::now()) {}
  ~_TimerInternal() {
    _end = std::chrono::high_resolution_clock::now();
    int64_t time =
        (std::chrono::duration_cast<std::chrono::microseconds>(_end - _start))
            .count();
    std::cout << _name << " timer: " << time / 1000.f << " ms" << std::endl;
  }

private:
  std::string _name;
  decltype(std::chrono::high_resolution_clock::now()) _start;
  decltype(std::chrono::high_resolution_clock::now()) _end;
};

// ##name放最后，有些编译器没法处理放前面的情况。
#define STACK_TIMER(name) auto _timer_##name = _TimerInternal(#name);
#define STACK_TIMER_START(name)                                                \
  auto _timer_ptr_##name = std::make_shared<_TimerInternal>(#name);
#define STACK_TIMER_END(name) _timer_ptr_##name = nullptr;

#include <fstream>

std::ifstream file("files.txt", std::ios::binary);
file.seekg(0, std::ios::end); // 到文件尾
size_t file_size = file.tellg();
file.seekg(0, std::ios::beg); // 返回文件首
file.close();

#include <fstream>
#include <sstream>

// 一个先计算文件大小创建文件buffer，随后调用文件的read接口
// 另外一个就是利用sstream

std::ifstream file("files.txt", std::ios::binary);
std::stringstream stream;
stream << file.rdbuf();
stream.str();

#include <thread>
#include <chrono>

...
// std::chrono::second, std::chrono::millisecond, std::chrono::microsecond
std::this_thread::sleep_for(std::chrono::second(2));
...

#include <random>

...

// 创建随机数生成器
std::random_device rd;
std::mt19937 gen(rd());

// 定义一个范围在[1, 100]之间的分布
std::uniform_int_distribution<> dis(1, 100);

// 生成随机数
int random_number = dis(gen);
...

const char *mad_kernel_source =
    R"(__kernel void mad_8uTo8u_elm4(__global const uchar *srcptr,
                              __global uchar *dstptr, int elm_size,
                              float multipler, float addend) {
  int offset = get_global_id(0) * 4;
  if (offset + 4 <= elm_size) {
    float4 pix = convert_float4(vload4(0, srcptr + offset));
    pix.x = mad(pix.x, multipler, addend);
    pix.y = mad(pix.y, multipler, addend);
    pix.z = mad(pix.z, multipler, addend);
    pix.w = mad(pix.w, multipler, addend);
    vstore4(convert_uchar4_sat_rtz(pix), 0, dstptr + offset);
  } else if (offset + 3 == elm_size) {
    float3 pix = convert_float3(vload3(0, srcptr + offset));
    pix.x = mad(pix.x, multipler, addend);
    pix.y = mad(pix.y, multipler, addend);
    pix.z = mad(pix.z, multipler, addend);
    vstore3(convert_uchar3_sat_rtz(pix), 0, dstptr + offset);
  } else if (offset + 2 == elm_size) {
    float2 pix = convert_float2(vload2(0, srcptr + offset));
    pix.x = mad(pix.x, multipler, addend);
    pix.y = mad(pix.y, multipler, addend);
    vstore2(convert_uchar2_sat_rtz(pix), 0, dstptr + offset);
  } else if (offset + 1 == elm_size) {
    (dstptr + offset)[0] = convert_uchar_sat_rtz(
        mad(convert_float((srcptr + offset)[0]), multipler, addend));
  }
})";