delete [] wskaźnik

friend punktnD operator + (const punktnD& pkt1, const punktnD& pkt2)
    {
        punktnD pkt(pkt1.wymiar>pkt2.wymiar?pkt1.wymiar:pkt2.wymiar);
        for(int i=0;i<pkt.wymiar;++i)
        {
            pkt.wsk[i]=(i<pkt1.wymiar?pkt1.wsk[i]:0)+(i<pkt2.wymiar?pkt2.wsk[i]:0);
        }
        return pkt;
    }

#include <iostream>
using namespace std;

class punktnD {
    int wymiar;
    int* wsk;
public :
    static int liczbaObiektow;
public: 
    punktnD(int n=2) :wymiar(n), wsk(new int[wymiar]) { 
        liczbaObiektow++; 
        cout << "konstruktor domyslny" << endl;
        cout << "wsk - " << *wsk << endl;
    }
    punktnD(const punktnD & pkt):wymiar(pkt.wymiar), wsk(new int[wymiar]) {
        int* tmp1 = pkt.wsk;
        int* tmp2 = wsk;

        for (int i = 0; i < wymiar; i++) {
            tmp2[i] = tmp1[i];
        }   
        cout << "konstruktor kopiujacy" << endl;
        liczbaObiektow++;
    }
    ~punktnD() {
        std::cout <<" destr\n";
        liczbaObiektow--;
        delete [] wsk;
    }

    friend punktnD operator + (const punktnD& pkt1, const punktnD& pkt2) {
        punktnD pkt;
        if (pkt1.wymiar < pkt2.wymiar)
            pkt.wymiar = pkt2.wymiar;
        else pkt.wymiar = pkt1.wymiar;

        int* tmp1 = pkt1.wsk;
        int* tmp2 = pkt2.wsk;
        int* tmp3 = pkt.wsk;

        for (int i = 0; i < pkt.wymiar; i++) {
            tmp3[i] = tmp1[i] + tmp2[i];
        }

        return pkt;
    }

    friend istream& operator >> (istream& kl, punktnD& pkt) {
        for (int i = 0; i < pkt.wymiar; i++) {
            cout << "podaj " << i << " element" << endl;
            cin >> pkt.wsk[i];
        }
        return kl;
    }

    friend ostream& operator << (ostream& kl, punktnD& pkt)
    {
        for (int i = 0; i < pkt.wymiar; i++) {
            cout << "element " << i << " :" << pkt.wsk[i]<< endl;
        }
        return kl;
    }
};

int punktnD::liczbaObiektow = 0;

void test() {
     punktnD p{3};
}

int main() {
   test();
}

#include <iostream>
#include <vector>

using namespace std;

template <typename T>
struct Counter
{
    Counter(){ ++counter; }
    Counter( const Counter& ){ ++counter; }
    inline static int counter {0};

protected:
    ~Counter() { --counter; }
};

class Point : public Counter<Point>
{

    vector<int> component;

public:

    Point( int n=2 ){component.resize(n,n);}

    friend Point operator+( const Point& point1, const Point& point2 )
    {
        Point point { ((point1.component.size()>point2.component.size()) ? point1 : point2) };

        size_t index {0};
        for( const auto& value : ( (point1.component.size()<point2.component.size()) ? point1.component : point2.component ) )
        {
            point.component[index++] += value;
        }

        return point;
    }

    friend ostream& operator<<( ostream& out , const Point& point )
    {
        for( const auto& element : point.component )
        {
            out << element << " ";
        }
        return out;
    }


};

int main()
{
    Point p1 {10} , p2 {20};

    auto p = p1 + p2;

    cout << p1 << endl ;
    cout << p2 << endl ;
    cout << p << endl ;

    cout << Point::counter << endl;

    return 0;
}