What is a multi paradigm programming language and what does "multi paradigm" mean?

Reprinted address :https://www.zhihu.com/question/20428688#:~:text=%E5%A4%9A%E8%8C%83%E5%BC%8F%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E4%B8%AD,%E8%8C%83%E5%BC%8F%E6%9D%A5%E6%92%B0%E5%86%99%E7%A8%8B%E5%BA%8F%E3%80%82

Programming paradigm refers to the guiding ideology of programming . In the programming language , It represents the design direction of this language , That is to say, language is to follow a certain , Or some kind of thought programming .

Multi paradigm in multi paradigm programming languages , It means that this language supports users to use many different programming paradigms to write programs .

C Language is a procedural programming language ;Java、C# Is an object-oriented programming language ;Haskell It's a functional programming language ; and C++ Is a multi paradigm programming language .

A few chestnuts ：

 Process type ：[C/C++]

#define COUNT_OF(ARR) (sizeof(ARR) / sizeof(*(ARR)))

int square(int x)
{
    
    return x * x;
}

int main(void)
{
    
    int numbers[] = {
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int results[COUNT_OF(numbers)];
    int i = 0;
    for (; i < COUNT_OF(numbers); ++i)
    {
    
        results[i] = square(numbers[i]);
    }
    return 0;
} 

object-oriented ：[C#]

interface CalcI
{
    
    int Square(int x);
}

class Calculate : CalcI
{
    
    public int Square(int x)
    {
    
        return x * x;
    }
}

class Iteration
{
    
    public int[] ForEach(int[] arr, CalcI cc)
    {
    
        int[] results = new int[arr.Length];
        for (int i = 0; i < arr.Length; ++i)
        {
    
            results[i] = cc.Square(arr[i]);
        }
        return results;
    }
}

class Program
{
    
    static void Main(string[] args)
    {
    
        int[] numbers = new int[] {
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        int[] results;
        Calculate cc = new Calculate();
        Iteration it = new Iteration();
        results = it.ForEach(numbers, cc);
    }
}

Generic ：[C++]

template <typename T>
auto square(T x)
{
    
    return x * x;
}

template <typename T, std::size_t N, typename F>
auto array_map(const T(& arr)[N], F fr)
{
    
    std::array<T, N> res;
    for (size_t i = 0; i < N; ++i)
    {
    
        res[i] = fr(arr[i]);
    }
    return res;
}

int main(void)
{
    
    int numbers[] = {
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    auto results = array_map(numbers, square<std::remove_extent_t<decltype(numbers)>>);
    return 0;
}

Functional expression ：[F#]

let square x = x * x
let numbers = [1 .. 10]
let squares = List.map square numbers
 Template element ：[C++]

template <size_t X>
struct square
{
    
    enum : size_t {
     value = X * X };
};

template <size_t... N>
struct array
{
    
    enum : size_t {
     count = sizeof...(N) };
};

template <typename Arr, template <size_t> class F>
struct array_map;

template <template <size_t...> class Arr, size_t... N, template <size_t> class F>
struct array_map<Arr<N...>, F>
{
    
    using type = Arr<F<N>::value...>;
};

int main(void)
{
    
    using numbers = array<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>;
    using results = array_map<numbers, square>::type;
    return 0;
}

You can see ,C++ Very flexible , Not stuck to a particular programming methodology .

A programming language belongs to a certain type , It doesn't mean that the language can only be programmed with that kind of thought . such as C Language , Although it is a process , But we can still use struct Abstract out class The concept of , Use function pointers and algorithms to simulate polymorphic features in object-oriented , It's just a lot of trouble . However, multi - paradigm language can freely switch between these paradigms it supports , There will be no reluctant astringency . Of course , The cost is that multi paradigm languages are generally more complex .