Возвратить массив из функции

protected:
    int ArrayLenght;
    int Amount;
    int *SortArray;
public:
     /*Sorting();
    ~Sorting();*/
    void SizeOfArry(int b)
    {
        SortArray=new int[b];
        ArrayLenght=b;
    }
    virtual int InputItems()
    {
        
        for(int i=0;i<ArrayLenght;i++)
        {
            SortArray[i]=rand();
            std::cout<<SortArray[i]<<"\n";
        }
        return 
    }

virtual int* InputItems()
{
   // ...
   return SortArray;
}

int Array[];
              Array=*InputItems();

int* Array;
       Array = InputItems();

int a; // Определение
extern int b; // Объявление

// ConsoleApplication10.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
#include <iostream>
#include <clocale>
#include <cstdlib>
#include <list>
#include <string>
#include <fstream>
#include <stdexcept>
#include <algorithm>
#include <cctype>
 
using namespace std;
 
class Sorting
{
protected:
    
    int Amount;
    int *SortArray;
public:
    int ArrayLenght;
     /*Sorting();
    ~Sorting();*/
    int SizeOfArry(int b)
    {
        SortArray=new int[b];
        ArrayLenght=b;
        return b;
    }
    virtual int* InputItems()
    {
        
        for(int i=0;i<ArrayLenght;i++)
        {
            SortArray[i]=rand();
            std::cout<<SortArray[i]<<"\n";
        }
        return SortArray;
    }
    virtual int* quickSort(int* Array,int a,int b)
    {
        return 0;
    }
    virtual void Result(int* Array)
    {
        ;
    }
};
 
 /*Sorting:: Sorting()
{
}
 
 Sorting::~Sorting()
{
}*/
 
 
 class Sort:Sorting
 {
 
 public:
    /* Sort();
    ~Sort();*/
     int* quickSort(int* Array,int left, int right) {
 
    int i = left, j = right;
    int tmp;
    int pivot = Array[(left + right) / 2];
 
    /* partition */
    while (i <= j) {
        while (Array[i] < pivot)
        i++;
        while (Array[j] > pivot)
        j--;
        if (i <= j) {
            tmp = Array[i];
            Array[i] = Array[j];
            Array[j] = tmp;
            i++;
            j--;
        }
    }
 
    /* recursion */
    if (left < j)
        quickSort(Array,left, j);
    if (i < right)
    quickSort(Array,i, right);
    return Array;
     }
 
     void Result(int* Array)
     {
         for(int i=0;i<SizeOfArry(22);i++)
         {
             std::cout<<Array[i]<<"\n";
         }
     }
 };
 
 /*Sort::Sort()
 {
 }
 
 Sort::~Sort()
 {
 }*/
 
 
 class Choice:Sorting
 {
 
 public:
     int* Array;
     /*Choice();
     ~Choice();*/
     void choise()
     { Sort sr;
         while (true)
         {
             system("cls");
            int option = 0;
            std::cout << "1 -\n"
                    << "2 - \n"
                    << "3 - \n";
                    
            std::cin.clear();
            std::cin.sync();
            std::cin >> option;
            switch(option)
            {
                case 1:
                    SizeOfArry(22);
                    Array=InputItems();
                    break;
                case 2:                 
                    Array=sr.quickSort(Array,0,21);
                    break;
                case 3:
                    sr.Result(Array);
                    break;
                case 4:
                    exit(0);
                default:
                    std::cout << "Неверный выбор\n";
            }
            system("pause");
        
         }
     }
 };
 
/* Choice::Choice()
 {
 }
 
 Choice::~Choice()
 {
 }*/
 
 int _tmain(int argc, _TCHAR* argv[])
{
    
    Choice ob1;
    ob1.choise();
    system("pause");
    //s1.InputItems();
    return 0;
}

#include <iostream>
 
using namespace std;
 
 
class Base
{
public:
    virtual void f() { cout << "Base::f()\n"; }
    virtual ~Base() {};
};
 
class Derived : public Base // Если убрать public, то будет по умолчанию использовать private
{
public:
    virtual void f() { cout << "Derived::f()\n"; }
};
 
 
int main() {
 
    Base* b = new Derived();
    
    b->f();
 
    return 0;
}