Recursively concatenate names

[Zivojin]

I have two classes FilySystemFolder and Folder.Folder is inherited from FilySystemFolder.Folder has array of pointers to FileSystemFolder.FileSystemFolder
has a poiter to Folder(*Folder).In folder there is a function that puts an item to an FilySystemArray.If you put folder a in folder b,b becomes its parent folder.Now you have to make name of the folder like concatenation of all it's parents folders.Here is my code:

  #pragma once
#include<string>

class Folder;

class FileSystemElement
{protected:
	char *ime;//name
	char *ekstenzija;//ekstension
	Folder *p;//pointer to parent folder
public:
	FileSystemElement() :p(nullptr), ime(nullptr), ekstenzija(nullptr){}
		FileSystemElement(const char * ime,const char *ekstenzija);
//I made teo constructors
	void Set_folder(Folder f);// makes p points to another folder
	Folder* PripadaFolder() { return p; }
	void Rekurzija();//This prototype of function for some recursion
	virtual ~FileSystemElement();
	virtual char * Vrati() = 0;
	virtual void PrintList() = 0;
//virtual functions defined in Folder.h
};
#include"Folder.h" 

FileSystemElement.cpp

  #include "FileSystemElement.h"

FileSystemElement::FileSystemElement(const char * ime, const char * ekstenzija)
{
	this->ime = new char[strlen(ime) + 1];
	strcpy_s(this->ime, strlen(ime) + 1, ime);
	this->ekstenzija = new char[strlen(ekstenzija) + 1];
	strcpy_s(this->ekstenzija, strlen(ekstenzija) + 1, ekstenzija);
	p = nullptr;
}

void FileSystemElement::Set_folder(Folder f)
{
	*p = f;
}

//void FileSystemElement::Rekurzija()
//{
	
//I do not know how to make a recursion 
//}

FileSystemElement::~FileSystemElement()
{
	delete ime;
	delete ekstenzija;
	delete p;
}

Folder.h

  #pragma once 
#include<iostream>
#include"FileSystemElement.h"

class FileSystemElement;
using namespace std;

class Folder:public FileSystemElement
{
private:
	FileSystemElement **m;
public:
	Folder() :FileSystemElement(nullptr, "")
	//ekstenzija(ekstension) is empty string in Folder
{
		m = new FileSystemElement*[2018];//array has to have 2018 spaces
		for (int i = 0; i < 2018; i++)
			m[i] = nullptr;
	}
	void ImeFolderu(char * name);
//Set name of the folder like concatenation of name and all parents names
	virtual ~Folder();
	virtual char* Vrati();//return name of Folder
	virtual void PrintList();//will be defined later
	void Dodaj(Folder *f);//Put folder in array
	void Ukloni(int i);//remove folder form an array
	Folder& operator=(const Folder &f);

  #include "Folder.h"

void Folder::ImeFolderu(char * name)
{
	Folder *x = this->PripadaFolder();//My idea is to see if Filder has 
//it's pointer points to something and concatenate it somehow
	if (x != nullptr)
		
}

Folder::~Folder()
{
	delete[]m;
}

char * Folder::Vrati()
{
	return nullptr;//for now
}

void Folder::PrintList()
{

}

void Folder::Dodaj(Folder *f)
{
	int i = 0;
	while (m[i] != nullptr)
		i++;
	m[i] = f;
	Set_folder(*f);

}

void Folder::Ukloni(int i)
{
	delete m[i];
	m[i] = nullptr;
}

Folder & Folder::operator=(const Folder& f)
{
	if (this == &f)
		return *this;
	for (int i = 0; i < 2018; i++)
		delete this->m[i];
	
	if (f.m)
	{
		for (int i = 0; i < 2018; i++)
			this->m[i] = f.m[i];

	}
	else
		m = nullptr;
	return *this;

}

[salem c]

> char *ime;//name
> char *ekstenzija;//ekstension
These should be std::string
Then you don't have to do all that manual memory management.

> Folder *p;//pointer to parent folder
If you gave it a better name, you wouldn't need a comment.
Folder *parentFolder;

> void Set_folder(Folder f);// makes p points to another folder
> Folder* PripadaFolder() { return p; }
Again, better names would be

void SetParentFolder(Folder *f) { parentFolder = f; }
Folder* GetParentFolder() { return parentFolder; }

> FileSystemElement **m;
Use a std::vector instead. Saves more of the roll-your-own memory management.
Nor is it limited to arbitrary 2018 entries.

You also need to take into account that folders can contain folders as well.