使用操作符重载实现能做加减乘除运算的向量Array

CMakeLists.txt

cmake_minimum_required(VERSION 2.6)

if(APPLE)
    message(STATUS "This is Apple, do nothing.")
elseif(UNIX)
    message(STATUS "This is linux, set CMAKE_PREFIX_PATH.")
    set(CMAKE_PREFIX_PATH /vcpkg/ports/cppwork/vcpkg_installed/x64-linux/share)
endif(APPLE)

project(sarray1)

add_definitions(-std=c++17)

add_definitions(-g)

find_package(ZLIB)

find_package(glog REQUIRED)

find_package(OpenCV REQUIRED )

find_package(Boost REQUIRED COMPONENTS
    system
    filesystem
    serialization
    program_options
    thread
    )

find_package(DataFrame REQUIRED)

if(APPLE)
    MESSAGE(STATUS "This is APPLE, set INCLUDE_DIRS")
set(INCLUDE_DIRS ${Boost_INCLUDE_DIRS} /usr/local/include /usr/local/iODBC/include /opt/snowflake/snowflakeodbc/include/ ${CMAKE_CURRENT_SOURCE_DIR}/../../include/ {CMAKE_CURRENT_SOURCE_DIR}/../)
elseif(UNIX)
    MESSAGE(STATUS "This is linux, set INCLUDE_DIRS")
    set(INCLUDE_DIRS ${Boost_INCLUDE_DIRS} /usr/local/include ${CMAKE_CURRENT_SOURCE_DIR}/../../include/ ${CMAKE_CURRENT_SOURCE_DIR}/../)
endif(APPLE)


if(APPLE)
    MESSAGE(STATUS "This is APPLE, set LINK_DIRS")
    set(LINK_DIRS /usr/local/lib /usr/local/iODBC/lib /opt/snowflake/snowflakeodbc/lib/universal)
elseif(UNIX)
    MESSAGE(STATUS "This is linux, set LINK_DIRS")
    set(LINK_DIRS ${Boost_INCLUDE_DIRS} /usr/local/lib /vcpkg/ports/cppwork/vcpkg_installed/x64-linux/lib)
endif(APPLE)

if(APPLE)
    MESSAGE(STATUS "This is APPLE, set ODBC_LIBS")
    set(ODBC_LIBS iodbc iodbcinst)
elseif(UNIX)
    MESSAGE(STATUS "This is linux, set LINK_DIRS")
    set(ODBC_LIBS odbc odbcinst ltdl)
endif(APPLE)

include_directories(${INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRS})

file( GLOB main_file_list ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) 

file( GLOB APP_SOURCES  ${CMAKE_CURRENT_SOURCE_DIR}/*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp ${CMAKE_CURRENT_SOURCE_DIR}/../../include/http/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../include/yaml/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../include/df/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../include/death_handler/impl/*.cpp)

add_library(${PROJECT_NAME}_lib SHARED ${APP_SOURCES})
target_link_libraries(${PROJECT_NAME}_lib ${Boost_LIBRARIES} ZLIB::ZLIB glog::glog DataFrame::DataFrame ${OpenCV_LIBS})
target_link_libraries(${PROJECT_NAME}_lib  ssl crypto libgtest.a pystring libyaml-cpp.a libgmock.a ${ODBC_LIBS} libnanodbc.a pthread dl backtrace)

foreach( main_file ${main_file_list} )
    file(RELATIVE_PATH filename ${CMAKE_CURRENT_SOURCE_DIR} ${main_file})
    string(REPLACE ".cpp" "" file ${filename})
    add_executable(${file}  ${main_file})
    target_link_libraries(${file} ${PROJECT_NAME}_lib)
endforeach( main_file ${main_file_list})

sarray1.hpp

#ifndef _FREDRIC_SARRAY1_HPP_
#define _FREDRIC_SARRAY1_HPP_

#include <cstddef>
#include <cassert>
#include <memory>

template <typename T>
class SArray {
    public:
        explicit SArray(std::size_t s): storage(std::make_unique<T[]>(s)),storage_size(s) {
        }

        SArray(SArray const& orig): storage(std::make_unique<T[]>(orig.size())), storage_size(orig.size()){
            copy(orig);
        }

        SArray<T>& operator=(SArray<T> const& orig) {
            if(&orig != this) {
                copy(orig);
            }
            return *this;
        }

        T operator[](std::size_t idx) const {
            return storage[idx];
        }

        T& operator[](std::size_t idx) {
            return storage[idx];
        }

        std::size_t size() const {
            return storage_size;
        }
 
    private:

        void copy(SArray<T> const& orig) {
            assert(size() == orig.size());
            for(std::size_t idx=0; idx<size(); ++idx) {
                storage[idx] = orig.storage[idx];
            }
        }
        std::unique_ptr<T[]> storage;
        std::size_t storage_size;
};

#endif

sarray1_ops1.hpp

#ifndef _FREDRIC_SARRAY1_OPS_HPP_
#define _FREDRIC_SARRAY1_OPS_HPP_

#include "sarray1.hpp"

template <typename T>
SArray<T> operator+(SArray<T> const& a, SArray<T> const& b) {
    SArray<T> result(a.size());
    for(std::size_t k=0; k<a.size(); ++k) {
        result[k] = a[k] + b[k];
    }
    return result;
}

template <typename T>
SArray<T> operator*(SArray<T> const& a, SArray<T> const& b) {
    SArray<T> result(a.size());
    for(std::size_t k=0; k<a.size(); ++k) {
        result[k] = a[k] * b[k];
    }
    return result;
}


// 标量左乘
template <typename T>
SArray<T> operator*(T const& s, SArray<T> const& b) {
    SArray<T> result(b.size());
    for(std::size_t k=0; k<b.size(); ++k) {
        result[k] = s * b[k];
    }
    return result;
}

// 标量右乘
template <typename T>
SArray<T> operator*(SArray<T> const& a, T const& s) {
    SArray<T> result(a.size());
    for(std::size_t k=0; k<a.size(); ++k) {
        result[k] = a[k] * s;
    }
    return result;
}


// 标量左加
template <typename T>
SArray<T> operator+(T const& s, SArray<T> const& b) {
    SArray<T> result(b.size());
    for(std::size_t k=0; k<b.size(); ++k) {
        result[k] = s + b[k];
    }
    return result;
}

// 标量右加
template <typename T>
SArray<T> operator+(SArray<T> const& a, T const& s) {
    SArray<T> result(a.size());
    for(std::size_t k=0; k<a.size(); ++k) {
        result[k] = a[k] + s;
    }
    return result;
}

#endif

main.cpp

#include "sarray1_ops.hpp"

#include <iostream>

int main(int argc, char* argv[]) {
    SArray<double> x(1000), y(1000);
    for(int i=0; i<x.size(); ++i) {
        x[i] = 1;
        y[i] = 1;
    }

    x = 1.2 * x + x * y;
    for(int i=0; i<20; ++i) {
        std::cout << x[i] << " ";
    }
    std::cout << "\n";
    
    return EXIT_SUCCESS;
}

本例有个要求，模板类型必须实现了默认构造函数，以便于std::make_unique<T[]>实现默认初始化。
本例使用std::unique_ptr管理内存，为此专门看了一把std::unique_ptr的源码。

image.png
image.png

程序输出如下，

image.png