prótesis biónica 0.0.6

/*Created by Móvil C.
 *project: ""prótesis biónica"" // main
 *User:[email protected]
 *Date:13-06-2022
 *Time: 22:15
 *Verton:0.0.6
 */
#include<stdlib.h>
#include<string.h>
#include<sstream>//sstream
using namespace std;
template <typename T>
typedef struct nodo{//has lo correcto.
    #define TAMANIO_STRUCT_NODO sizeof(nodo)/2
    #define TAMANIO_T sizeof(T)/2

    nodo*anterior[TAMANIO_STRUCT_NODO]={this,nullptr},
        *siguiente[TAMANIO_STRUCT_NODO]={this,nullptr},
        *ortogonalAnterior[TAMANIO_STRUCT_NODO]={this,nullptr},
        *ortogonalSiguiente[TAMANIO_STRUCT_NODO]={this,nullptr};//new nodo[4];
    T*dato[TAMANIO_T]={nullptr};//arreglo de punteros
    unsigned long int tamanioInterno=0,
                      tamanioOrtogonal=0;//Bug de tamanios?,reviza aqui' o en el arreglo.

    nodo():dato({nullptr}),tamanioInterno(0){
        anterior=siguiente=ortogonalAnterior=ortogonalSiguiente={this,nullptr};
    };
    nodo(T*datoOriginal):dato({datoOriginal,nullptr}),tamanioInterno(0),ortogonalAnterior({this,nullptr}),ortogonalSiguiente({this,nullptr}){//basura.set(nullptr);
        if(datoOriginal){
            for(;datoOriginal[tamanioInterno];tamanioInterno++);//noRecursivo.
            if(1<tamanioInterno){
                if(2<tamanioInterno){//3;
                    anterior={new nodo(&datoOriginal[tamanioInterno/2],tamanioInterno/2),nullptr},
                    siguiente={new nodo(datoOriginal,tamanioInterno/2),nullptr};
                }else anterior={new nodo(&datoOriginal[1],1),nullptr},//2;
                     siguiente={this,nullptr};
            }else anterior=siguiente={this,nullptr};//0 y 1;
        }else anterior=siguiente={this,nullptr};//nullptr->
    };
    nodo(T*datoOriginal,unsigned long int tamanio):tamanioInterno(tamanio),ortogonalAnterior({this,nullptr}),ortogonalSiguiente({this,nullptr}){
        if(datoOriginal)
            dato={&datoOriginal[tamanio/2],nullptr};
        else dato=nullptr;
        if(1<tamanioInterno){
            if(2<tamanioInterno){//3;
                anterior={new nodo(&datoOriginal[tamanioInterno/2],tamanioInterno/2),nullptr},
                siguiente={new nodo(datoOriginal,tamanioInterno/2),nullptr};
            }else anterior={new nodo(&datoOriginal[1],1),nullptr},//2;
                 siguiente={this,nullptr};
        }else anterior=siguiente={this,nullptr};//0 y 1;
    }
    nodo(T*listaOriginal[],unsigned long int x,unsigned long int yIndependientes[x]):tamanioInterno(x){
        if(listaOriginal){
            if(listaOriginal[x/2]){
                //new nodo(listaOriginal[x/2][yIndependientes[x/2]/2]);
                if(listaOriginal[x/2][yIndependientes[x/2]/2]){
                    *dato[0]=listaOriginal[x/2][yIndependientes[x/2]/2];

                    anterior={new nodo(listaOriginal,x,yIndependientes),nullptr};
                    siguiente={new nodo(listaOriginal,x,yIndependientes),nullptr};

                    ortogonalAnterior={new nodo(listaOriginal,x,yIndependientes),nullptr};
                    ortogonalSiguiente={new nodo(listaOriginal,x,yIndependientes),nullptr};

                }else{}
                ///
            }else{
                ///
            }
            ///
        }else{///
        }
    };
    nodo(T*listaOriginal[]):dato({nullptr,nullptr}),tamanioInterno(0),ortogonalAnterior({this,nullptr}),ortogonalSiguiente({this,nullptr}){
        ///x[0][0]==*x[0]==**x ///(listOriginal[0]==*listOriginal) ///listaOriginal
        if(listaOriginal){
            int x;
            for(x=0;listaOriginal[x];x++);
            int y[x];
            for(int i=0;i<x;x++)
                for(y[x]=0;listaOriginal[x][y[x]];y[x]++);//no recursive
            dato[0]={&listaOriginal[x/2][y[x]/2],nullptr};
            ////
        }else{}
        ////
        /*experimental
        if(listaOriginal){
            stringstream ss;
            T lista[]={nullptr},*auxiliar[]={nullptr};
            for(int i=0;listaOriginal[i];i++,ss.clear()){
                ss<<listaOriginal,
                ss>>lista;
                cout<<ss.rdbuf()<<"rd bufer";
                for(int j=0;lista[j];j++){
                    (*auxiliar)[j]=new T(lista[j]);
                }
            }
        }*/
        //{0xejemplo ,new T()->{T0,basura},...,nullptr,basura},{nullptr,basura},
        //{new T()->{T0,basura},basutra} o
        //{new T[x]->{T1,T2,...Tn,basura},basura},{nullptr,basura},{0xejemplo,basura}
        if(listaOriginal){//0xff->
            if(*listaOriginal){//puntero a un arreglo *original is == original[0];
                stringstream ss;
                T lista[]={nullptr};
                for(int i=0;listaOriginal[i];i++,ss.clear()){
                    ss<<listaOriginal[i];
                    cout<<listaOriginal[i];
                    ss>>lista;
                    cout<<lista;
                }
            }else{
            }
            if(listaOriginal[0]){//arreglo de punteros
            }else{
            }
        }else{//do nothing;
        }
    };
    nodo(T*listaDeDatos[],unsigned long int x,unsigned long int y):tamanioInterno(x),dato({listaDeDatos[tamanioInterno/2],nullptr}){
        if(1<tamanioInterno){
            if(2<tamanioInterno){
                siguiente[0]=new nodo(listaDeDatos[(tamanioInterno/2)],(tamanioInterno/2));
            }
            anterior[0]=new nodo(listaDeDatos[0],(tamanioInterno/2));
        }else if(tamanioInterno){
            anterior[0]=new nodo(&listaDeDatos[(tamanioInterno/2)]);
        }else{}
    };

    nodo(unsigned long int x,unsigned long int y,T*lista[]);
    nodo(unsigned long int tamanio,unsigned long int*tamanioDevectores[],T*lista[]);

    nodo(nodo*raizAntigua):dato({raizAntigua->dato,nullptr}),anterior(raizAntigua->anterior),siguiente(raizAntigua->siguiente),ortogonalAnterior(raizAntigua->ortogonalAnterior),ortogonalSiguiente(raizAntigua->ortogonalSiguiente){};

    ~nodo(){}
};
int main(int argc,char*argv[]){///number, *location[]
    stringstream zz;
    cout<<argc<<endl;
    cout<<argv<<endl;
    if(argc){
        cout<<"*"<<(*argv)<<endl
            <<(*argv)[9/2]<<"["<<9/2<<"]"<<endl;//4
        cout<<"0'"<<argv[0]<<"'"<<endl;
        cout<<"1'"<<argv[1]<<"'"<<endl;
        if(argv[2]){cout<<"2'"<<argv[2]<<"'"<<endl;//trow obiusly.
        }else{
            cout<<"2'"<<"is nullptr"<<endl;
        }//static_cast<char>(new char[])
        // axess string => sstream => *type[];
        //argv[2]=*xyz;//new char('c');
        argv[2]=new char('ops!');//,//new char('/0')};
        //cin>>(argv[2]);
        //*(argv[2])=;

        zz<<"aqio";
        zz>>argv[2];
        argv[2]="tfhnju70j8yy";
        cout<<argv[2][8];
        cout<<"2'"<<argv[2]<<"'"<<endl;
        argv[3]=nullptr;
        argv[4]=nullptr;
        //char*ijk=new char[5];
        //ijk="rghujb";
        if(argv[3]){cout<<"3'"<<argv[3]<<"'"<<endl;//trow obiusly.?
        }else{
            cout<<"3'"<<"is nullptr"<<endl;
        }
        //argv[3]=new char('d');
        //cout<<"2'"<<argv[4]<<"'"<<endl;

        return main(0,argv);
    }
    return 0;
}
/*arguments.
> main.cpp 2ws
2
* /storage/emulated/0/Documents/not suport media./proyecto de junio./main.cpp.bc
/[0]
1
* /storage/emulated/0/Documents/not suport media./proyecto de junio./main.cpp.bc
/[0]
0
*/
/*argc será el número de cadenas apuntadas por argv.  Esto será (en la práctica) 1 más el número de argumentos, ya que prácticamente todas las implementaciones antepondrán el nombre del programa a la matriz.*/