A las güenas :-)

Asco de Martes :-(

@abulafia En todos los ejemplos que veo con async.create_subprocess_exec( ), la llamada a subprocess#communicate( ) no retorna hasta que el hijo muere. ¿ Como sería para mantener un diálogo durante un tiempo indeterminado ?

Me interesa recibir todas las salidas del proceso hijo, por stdout y stderr, durante el indeterminado tiempo en que permanezca en ejecución

Buenos dias

@Trauma No entiendo bien... ¿para ir haciendo en paralelo alguna otra cosa, o qué? communicate() te devuelve todas las salidas del proceso hijo que se produzcan durante el indeterminado tiempo en que permanezca en ejecución, solo que no las tienes todas hasta el final. ¿para qué necesitas ir teniéndolas a medida que se produzcan? (pregunto para orientar la solución)

Ten en cuenta por otro lado que al ser stdout bufereada de todas formas no las vas a tener "en tiempo real" nunca (aunque stderr sí)

@abulafia Proque quiero loguearlas por mi cuenta

Mandarlas a un archivo o a un socket o a donde sea que esté configurado

La idea es supervisar al hijo (o hijos). Y si muere, pues relanzarlo otra vez.

En la doc pone que no se debe acceder directamente al child.stdout porque puede haber problemas

@Trauma Sí, lo he leido pero no lo entendí

Algún tema interno de asyncio supongo, aunque yo tampoco le veo mucho sentido ... pero la doc es la doc

Miraste esto? docs.python.org/3/library/…

Ahora estoy en una reunion y no puedo mirarlo, más tarde a ver si te puedo echar una mano. Es código de bajo nivel y farragoso. ¡Lo que a ti te gusta!

@abulafia jejeje ... gracias, le echo un ojo ;-)

Pain

Hola buenos dias

alguien de aca sabe algo de angular?

la mitad del sitio menos yo :p

jajajaja

ando con un problema al momento de hacer un post

con axios?

o fetch?

ajax

$scope.addPost = function(){
    $http.post("https://jsonplaceholder.typicode.com/posts",{
        title: $scope.newPost.title,
        body: $scope.newPost.body,
        userId : 1
    })
    .then(function successCallback(response, status, headers, config){
            console.log(response, status);
            $scope.posts.push($scope.newPost);
            $scope.addPost={};
    },function errorCallback(response, status, headers, config){
        console.log(response);
    })
}

ehhh... ajax es la tecnologia... como haces el post?

tengo este codigo y al momento de hacer el post me tira que push no es una function

porque posts no es un array...

esto es un problema de scope... a ver alguno que sepa js...

@gbianchi si te referis a eso lo hice un array

o scope le esta dando nulo ahi adentro...

sino le puedo sacar el array

si, pero en js tenes un problema de scope... como es una funcion asincronica, pierde los tipos al entrar en el then, salvo que tengas un this para que sepa que es...

ahora te busco la publicacion...

pero lo mas probable es que tengas que hacer algo tipo:

ahora pruebo

Donde esta pablo cuando se lo necesita?

@gbianchi me rompio todo jajajaja

yo no se porque me haces caso si yo no se de eso :p

y... hay que intentar tood

todo*

tu mismo problema

el tema es que le console.log me retorna el json bien hecho

lee

el json no tiene nada que ver con el lugar a donde lo queres meter

te estoy buscando la documentacion de scope.. porque es lo importante de entender en js

mismo error

aunque lo asigne a una var

@ZeroSour a ver tu codigo

lo pase mas arriba

o queres el codigo entero?

el cambiado

$scope.addPost = function(){
    $http.post("https://jsonplaceholder.typicode.com/posts",{
        title: $scope.newPost.title,
        body: $scope.newPost.body,
        userId : 1
    })
    .then(function successCallback(response, status, headers, config){
            let scope = $scope;
            console.log(response, status);
            scope.posts.push(scope.newPost);
            scope.addPost={};
    },function errorCallback(response, status, headers, config){
        console.log(response);

lo unico diferente seria el let scope arriba del console.log

ah ah

let scope = $scope; va antes del post

al arrancar la funcion

osea que lo declare arriba del todo?

sip... porque vos necesitas que scope, tenga el scope para toda la funcion.. una vez que hiciste el post, el scope se perdio porque then se ejecuta en otro lado...

al hacer llamadas asincronicas se arma un arbol de ejecucion, y js pierde las variables que tenia de antes, salvo que las guardes explicitamente.. y al hacer let scope = $scope la estas guardando

sigue tirando error

buscate al usuario Pablo Lozano despues, y leete las dos respuestas que mas votos tienen de el...

TypeError: scope.posts.push is not a function

nunca te pase el error igual

$scope.addPost = function(){
    let this = $scope;
    $http.post("https://jsonplaceholder.typicode.com/posts",{
        title: $scope.newPost.title,
        body: $scope.newPost.body,
        userId : 1
    })
    .then(function successCallback(response, status, headers, config){

            console.log(response, status);
            this.posts.push(this.newPost); <- aca no es response?
            this.addPost={};
    },function errorCallback(response, status, headers, config){
        console.log(response);

esta asi ahora literalmente

a ver.. mira el codigo... me suena que tenes varias problemas...

decis que sea response.newPost?

y me parece que si.. vos no queres agregar los nuevos post a tu lista?

y que hace addpost vacio despues?

@gbianchi para vaciarlo

para que no se quede repetido en el form

pregunte por aca por la ofi y nada...

Eso está bien @ZeroSour

Debe ser this.newPost

el tema es que si uso this me explota todo

Piénsalo un momento. this.newPost es lo que envías al back. Si todo va bien en el back, entonces lo añadimos al Array de posts.

al momento de cambiar el scope por this el front deja de funcionar

@ZeroSour pues entonces usas un bind en la función succesCallback

Cagóntoloquesemena

cannot convert from 'initializer list' to 'xva2proto::EnumComparator<ProtoKindType,FolKindType>'

Hastaloscajones me tiene estoy hoy

De verdad que Asco de Martes

@MauricioContreras Como seria eso?

@Trauma, nada que Python no haga más fácil

Esto de C++14 y tirar de las boost da mas caló de esperado

Mucho mas :'-(

Me parece que no puedo construir un std::pair< boost::optional< Enum1 >, boost::optional< Enum2 > > pasando directamente valores de los Enum

Pues a ver como carajo lo voy a hacer entonces O_º

@ZeroSour supongamos que has declarado tu función en otra parte, como: const successCallback = function(...) {...}

que bueno llego alguien que sabe

Luego en tu método then la pones así: then(successCallback.bind(this)) con eso lo tendrías.

entonces declaro la succesCallback arriba?

De todas formas, has de probarlo. Pero es lo que yo intentaría. Ando desde el móvil y escribo de memoria. XD

tipo antes de todo

Sip

@MauricioContreras okok ahora lo intento

@Trauma podrías usar puntero a puntero y a saber lo que pasa. Total, si complia y no explota ya es un avance.

Escribo el cuerpo de la function al momento de declararla o la escribo al invocarla luego del then?

@ZeroSour al momento de declarar

@MauricioContreras Tu, no vengas a tocarme la moral, que no está el bollo p'a hornos ;-p

Que llevo ya un buen rato con esto, y todavía no entiendo el error

@Trauma creo que el error es muy claro: C++

XD

lO_º

Tosusmuertos

Esto compila: std::pair<ProtoKindType, FolKindType> test(ProtoKindTypeEnum::CollateralSetRule_RuleKindType_HAIRCUT, FolKindType());

Pero eso mismo, si lo meto en un std::initializer_list< >, deja de compilar

Igual yo he puesto pausa por vacaciones mi incursión en C. Pero en Septiembre retomo el asunto y a ver si a principios de 2023 ya empiezo a trabajar con C++.

@MauricioContreras Ya preguntarás ya ... que verás las respuestas que te voy a dar ;-p

Eso, que supongo que serán de todo, menos amistosas. Mientras no sean sobre ingenierizadas

A ver si forzando el tipo del initializer_list ...

@MauricioContreras Je. No te haces una idea de La Imaginación que tengo jejeje

Vete preparando jejeje

Mejor preguntale a Paula... Trauma tiene problemas...

@gbianchi Muchos y Variados xDD

¡ Copón !

Nada, que dice que no hay constructor

creo que el problema esta que no me esta tomando el $scope.posts como un array

aunque lo haya declarado como tal

¿¿ Y esto que es, entonces ?? EnumComparator(std::initializer_list<std::pair<boost::optional<PROTO>, boost::optional<FOL>>> values)

@ZeroSour estmos seguros que es un array? como lo declaraste? que pasa si antes de esa funcion tratas de agregarle algo, se lo agrega o tira el mismo error?

@Trauma japones o ruso?

@gbianchi $scope.posts = [];

es que no tira error

pero al momento de querer que muestre algo no muestra nada

y se supone que ya tiene datos ese array

me estas cambiando el problema...

por consola muestra?

es que el problema esta ahi

yo antes de cargar hago un $http.get y lo guardo en ese array

pero al mostrar por front

me toma como si no hubiera valors

ah ah.. eso es otra cosa... por consola tiene datos?

lo que puede estar pasando son dos cosas

se lo estas cargando a otro array

o ese array que vos pensas que tiene datos, no tiene

@gbianchi probablemente este cargando otra cosa

sino no se

es angular no? podes mostrar la variable directamente en el front... no?

si... los datos los añade al array

pero es el mismo array.. o es un array ;)

ojo con eso...

y... el $scope.posts = [] no es porque sino lo mostraria el front

pero le hice un $scope.post = (lo que necesitaba insertar)

Angular? Eso se trabaja con observables. Es toda una movida

Vale, ya compiló. Copón.

Al final, un typo. Si es que a veces me tiraría por la ventana :-/

estaba mal declarando el array

buenas buenas

declaraba el array al inicio y luego lo reemplazaba por response entonces dejaba de ser un array para ser un response

al momento de hacer $scope.posts.push(response) el programa funciono sin dramas

$scope.post = (lo que necesitaba insertar) el problema era esto

cuando lo cambie por $scope.posts.push() ahi todo funciono bie

bien*

ahhh viste...

bien que lo arreglaste!!! 👍

Un typo? @Trauma? A estas alturas de la vida?

De verdad que el calor te está afectando

@MauricioContreras puffff ... y lo que te rondaré morena xD

No es tan difícil equivocarse, no te creas:

   using ProtoKindTypeEnum = ::bbva::protointerfaces::appconfig::xvaengine::v1::CollateralSetRule_RuleKindType;
    using FolKindTypeEnum = FOLCollateralSetRuleType::RuleKind;
    using ProtoKindType = boost::optional<ProtoKindTypeEnum>;
    using FolKindType = boost::optional<FolKindTypeEnum>;

@LucasDamian don Lucas. Se le saluda

@Trauma con esa cantidad de bloat code, claro que no es difícil. Al contrario, sería muy sorprendente el no equivocarse

Veo un bbva por allí. Coincidencia o trabajas para los vascos? @Trauma

@MauricioContreras Si quiero que las líneas me quepan en mi monitor de 27", tengo que abreviar

@MauricioContreras Es correcto, estoy con ellos

@Trauma comprar un monitor UWS

seguro que tu amigo el experto lo escribia mucho mejor el codigo ese...

@gbianchi seguramente, y de paso optimizado

@MauricioContreras El que tengo es de 2560x1440

Y NO CABEN en cuanto te descuidas

@MauricioContreras jejeje ... se entera mi AÚ de que me he gastado 400€ en un monitor ... no te digo nada xDD

@Trauma cuestan menos de 200 algunos de ellos. No deben ser curvos, sólo amplios

No no. Que me pego 8 horas mínimo mirándolo fijamente, con odio y asco

Tiene que ser de los güenos

pccomponentes.com/…

@Trauma si si bueno... pero es por tu salud...

hay que cuidar esos ojitos claros (?)

@gbianchi que si que si ... que ya cuando te pases por aquí por la costa se lo explicas tú

Me da que mientras ingrese €€€ a fin de mes, la salud de mis ojitos claros no termina de importarle mucho ...

@Trauma pero para que ingresen los ojitos tienen que estar bien

@gbianchi Que si que si ... pero eso es mas abstracto, mas ... a largo plazo ...

decile que no podes leer el prospecto del medicamento por culpa de que tu monitor es chiquito...

¡ HAHAHAHA !

@abulafia Encontré un ejemplo de lo que intento:

A ver de que tamaño es la explosión xD

Buenas gente.. Busco opiniones. Tengo que diseñar una herramienta de escritorio (accede a recursos locales) bastante sencilla, dos o tres "pantallas", sería de uso interno de desarrolladores, acceso a bd e interacción con la API de github, tiempo de vida, al menos 15 años. En principio iría por el lado de Visual Studio (c#). La duda es en cuanto a la GUI, ¿para dónde apunto? ¿Winforms, WPF, MAUI? El primero lo conozco bastante, con el resto no hice nunca nada.

MAUI es el futuro, donde el foco de MS va a estar de ahora en más. Ya está lista para uso en producción, pero podés encontrar que el tooling todavía no está al 100% todavía

yo si fuera vos iría por MAUI

@PatricioMoracho MAUI

te va a llevar un poquito mas, pero vas a tener mas soporte a futuro

en el peor de los casos, la podes hacer en wpf (por el tooling, solo los diseños) y despues migrarla

ya tenemos a @NicolasOñate como experto (?) preguntale a el

Mmmmm. MAUI = Mau Intelligence. Yo no apostaría mucho allí. XD

Igual entre las plataformas múltiples que dicen ofrecer, se dejaron Linux fuera de la foto. :/

@MauricioContreras no no.. es para linux tambien

ah tenes razon.. no esta para linux

@gbianchi haberlo puesto en la foto. Una imagen vende mucho.

pero supongo que faltara solamente algiuen que la porte...

Ves?

Pues será. Como siempre MS me discrimina. Patriarcado opresor

XD

@Trauma Ah, pero eso usa una tubería ¿era eso lo que buscabas?

@MauricioContreras jajajaj pero esta en mono.. es cuestion que la portes...

@gbianchi tal parece que si está para Linux:

docs.microsoft.com/es-es/dotnet/maui/…

@Trauma Esto me funciona, pero solo leo de stdout (y no escribo nada en el stdin del subproceso, que es de donde pueden aparecer los problemas, creo)

import asyncio

async def run(cmd):
    proc = await asyncio.create_subprocess_shell(
        cmd,
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE)
    while True:
        linea =  await proc.stdout.readline()
        if not linea:
            break
        print("Del proceso:", linea.decode("utf-8"))
    print("El proceso hijo terminó")

asyncio.run(run('python -u ejemplo.py'))

El script ejemplo.py que lanzo como subproceso es una tontada, para probar:

import time

for i in range(5):
    print(i)
    time.sleep(1)

print("Terminé!")

@Trauma y aquí tienes otra versión que demuestra que hay concurrencia

import asyncio

async def run(cmd):
    proc = await asyncio.create_subprocess_shell(
        cmd,
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE)
    while True:
        linea =  await proc.stdout.readline()
        if not linea:
            break
        print("Del proceso:", linea.decode("utf-8"))
    print("El proceso hijo terminó")

async def otra_cosa():
    for i in range(15):
        print("Otra cosa:", i)
        await asyncio.sleep(0.5)

async def demo():

MAUICIO

@LucasDamian MAUI + asynCIO

@abulafia No, no era eso :-(

@gbianchi Lo había pensado, el tema es que por ahora estoy anclado en el Visual Studio 2019

@abulafia Algo así estoy haciendo. Al final, pasando de la doc y tirando de subprocess.stdout y stderr xDD

Si el problema es el stdin, no pasará nada. No se usa.

@Trauma me ayudas con un problema de listas enlazadas?

Por alguna razón solo tengo 2 elementos. El primero y el último

@Christian Haz la pregunta, y a partir de ahí ya vamos viendo. Se te van los días solo en preguntar si alguien te ayuda xD

@PatricioMoracho entonces te diria que uses wpf para poder portarlo en cuanto puedas...

@Christian si tenes una lista con dos elementos, es porque perdiste los del medio :p

Así parace...

Tengo este código:

void appendJugada(Movimiento *&mov, int x, int y){
    Movimiento *new_mov = new Movimiento();
    new_mov->player_x = x;
    new_mov->player_y = y;

    Movimiento *aux1 = mov;
    Movimiento *aux2;
    if(mov == nullptr){
        mov = new_mov;
        mov->sig = aux1;
    }else{
        mov->sig = new_mov;
    }
}

@gbianchi Si, por lo que ví usa XAML que lo siguieron usando para todo lo que vino después.

:/

@PatricioMoracho si si.. XALM es para xamarin y ahora para MAUI

if(mov == nullptr)

?

por eso, se supone que podes ir directamente..

Movimiento *&mov?????!??!?!?!?!??????

Eso dijo el chico del video ....

es una indireccion media rara no.. es la direccion del puntero?

@Christian Que cosa mas fea ... y eso de usar los argumentos de la función para modificarlos ... que mal futuro te auguro xDD

Estas en C++ ¿ porque no usas clases ?

¿ O es que en python todo lo haces con funciones también ?

jajaj nop

¿ Entonces ?

appendJugada al final???? o a cualquier lado?

al final

y le estas pasando siempre el final de la lista?

O_O

(mas alla de todo lo que trauma dice y tiene razon)

acabo de ver que siempre le estoy pasando la lista

@Christian pues cambia de video o mejor de chico.

@Christian y en que momento estas yendo al final?

@MauricioContreras +2783641978364178963871

*yendo <- gracias

@Christian aux2 no se usa, aux1 te lo puedes ahorrar y está feo así como lo tienes

Bueno, voy a pasarlo a una clase

Si, es que mejor nos pasa el link del video para dejarle unos sórdidos comentarios

También te puedes ahorrar el paso por referencia de mov si te aseguras de que al invocarla nunca le pasas un puntero nulo. Es decir, que el primer elemento de la lista se crea fuera de la función esa

@Christian Parece estar bien ... pero, por deity, quita esas variables sin usar y haz un código que se entienda

@MauricioContreras El chico está muerto

@Trauma no esta bien, es ilogico

@Christian pues mira tú, su legado no parece muy fructífero. :/

bastante personas lo admiran

programación ATS

@Christian muchos admiraban a un tal Adolfo, pero no por eso significa que fuera bueno. XD

@Christian

Movimiento *appendJugada(Movimiento *mov, int x, int y){
    Movimiento *new_mov = new Movimiento();
    new_mov->player_x = x;
    new_mov->player_y = y;

    if(mov == nullptr){
        new_mov->sig = nullptr;
        return new_mov;
    }

    mov->sig = new_mov;

    return mov;
}

movimiento = appendJugada( movimiento, 10, 20 );

void appendJugada(Movimiento *&mov, int x, int y){
//creo un nuevo movimiento, lo lleno
    Movimiento *new_mov = new Movimiento();
    new_mov->player_x = x;
    new_mov->player_y = y;
//creo una variable auxiliar para vaya a saber uno que
    Movimiento *aux1 = mov;
//creo otra variable auxiliar que no voy a usar
    Movimiento *aux2;
//me fijo si la lista que pase, es nula
    if(mov == nullptr){
//es nula, le asigno lo que acabo de crear
        mov = new_mov;
//Le asigno null de una forma muy poco ortodoxa

@gbianchi XDDDDDDDDDDD

Recién estoy aprendiendo -_-

@Trauma siempre y cuando no pases la punta de la lista.. y pases el ultimo nodo

Digo yo... no es esto lo mismo? (salvo un detalle que comento luego)

void appendJugada(Movimiento *mov, int x, int y){
    Movimiento *new_mov = new Movimiento();
    new_mov->player_x = x;
    new_mov->player_y = y;
    mov->sig = new_mov;
}

Suponiendo que le pasas el último nodo de la lista, claro. Y que no sea null

@abulafia +238729847289374287964782

@abulafia Si mov es nulo, fallará

@Trauma Si, eso acabo de decir

se especifica en la documentación :-)

que ni equivocarse puede ya uno :-(

es una api de mierda, pero explota poco (?)

forzar a que no sea nulo evita el tener que pasarlo por referencia y que la función lo modifique, que está muy feo

¡¡ Que use una clase, carajo !!

¿¡ Donde se ha visto un programador python que no use clases !?

no hombre.. a ver si aprende POO y despues se mete con J

Por muy aprendiendo que esté

algunos usamos paradigma funcional

yo también, siempre que puedo

aca programan cobol y no por eso les digo a todos que hagan cobol

de hecho, cada vez soy más proclive a lo de las funciones puras

y la clase es el marco de control de las llamadas a las funciones :-)

estos de python estan mal....

pero ya que las funciones guardan estado en la clase, ya no son puras

yo suelo usar funciones normales, y pasarles los atributos de la clase. La clase controla la llamada

la mayoría del código está en las funciones sueltas

Siempre que se pueda, claro :-)

@Trauma por eso vivis con errores tipograficos (?)

XDDDDD

Porque el cliente es un OBSESO de los namespaces

hasta los punto-y-coma tienen su propio namespace

no le digas OBESO que no puede defenderse...}

jejeje

Mi cerebro murió al querer ponerlo en una clase

Si es que tienes líneas de 80 caracteres .. ¡ Antes de empezar !

Voy a almorzar, es mejor pensar con el estómago lleno

la clase lista deberia tener una funcion devolver ultimo

y ya con eso, haces magia

thanks, lo intento luego

@Christian La librería tiene una lista que puedes usar de ejemplo para el API

en.cppreference.com/w/cpp/container/list

Ese API se sigue en casi todos los contenedores, para poder usar <algorrithm> con cualquiera

@Trauma algor rithm Ritmo de Algor

Maravilla del señor

class Movimiento {
    public:
    int player_x, player_y;
    Movimiento *sig = nullptr, *ultimo = nullptr;
    void append(int x, int y){
        Movimiento *new_mov = new Movimiento();
        new_mov->player_x = x;
        new_mov->player_y = y;
        if(ultimo == nullptr) sig = new_mov;
        else ultimo->sig = new_mov;
        ultimo = new_mov;
    }
};

Hmm... no sé si me convence. Movimiento sería un nodo de la lista. Por otro lado deberías tener la propia lista, que es la que tiene que proporcionar métodos de insertar, buscar, borrar... no el nodo. Y sería la lista la que contendría un puntero al primer elemento (y si quieres por eficiencia al último, para hacer más rápida la inserción)

O sea debería tener una clase, por ejemplo List_Movimientos y que cada elemento sea una struc Movimiento, algo así?

Si. O ya, si sabes usar templates, tener una clase List genérica, que concretarías como List<Movimiento>

una lista en sí mismo es un tipo de datos, independiente hasta cierto punto del tipo de los elementos que contiene. La lista es algo que te proporciona una interfaz para insertar elementos, interar sobre ellos, eliminarlos, etc. Los objetos que metes ahi ya serían los que guardan la información necesaria (y tendrían un campo sig adicional para enlazar unos con otros)

Entiendo, voy hacer eso

Gracias :D

@abulafia así?

template <typename T>
class List {
    public:
    T *elementos = new T[1];
    int size = 0;
    T *ultimo = nullptr;
    void append(T elemento){
        if(size == 0) elementos[0] = elemento;
        else{
            T *new_arr = new T[size + 1];
            for(int i = 0; i < size; i++) new_arr[i] = elementos[i];
            new_arr[size] = elemento;
            delete[] elementos;
            elementos = new_arr;
            ultimo = elemento;
        }
    }
};

No domino lo suficiente C++ para saber si la sintaxis es correcta, o si el código viola alguna "buena práctica". @Trauma te dirá mejor. Pero de momento lo que veo es que has decidido usar un array para almacenar los elementos de la lista, en vez de punteros al siguiente como usabas en el enfoque anterior. Usar el array no tiene por qué ser malo, pero supongo que es ineficiente crear un array nuevo, copiar todo y borrar el antiguo para cada inserción

seguro que hay forma mejor de hacerlo, algún tipo de realloc. Y hacer como python, que en lugar de aumentar el tamaño de 1 en 1, lo va haciendo en trozos cada vez mayores. La lista "inicial" puede tener sitio para varios elementos en vez de uno, y cuando haya que aumentarla puedes elegir duplicar su tamaño en vez de meter uno más

No creo que esté mal, es lo que me enseñó Trauma ._.

de ese modo evitas todo ese "movimiento" de datos en cada inserción

De momento lo hice así para entender mejor, ahora lo implemento con punteros

necesitarías guardar dos contadores: el tamaño máximo de la lista y el tamaño actual

cuando el tamaño actual alcance al máximo, es cuando necesitas aumentar a un tamaño mayor (y actualizar ese máximo)

Mi cerebro volvió a morir

Cómo se supone que haga que el elemento actual apunte a null?

si no conozco de que tipo de dato es

null no depende del tipo. Un puntero a cualquier cosa puede apuntar a null. No?

Entonces lo estoy implementando mal >_<

template <typename T>
class List {
    private:
    const int MAX_SIZE = 10;

    public:
    T *elementos = new T[MAX_SIZE];
    int size = 0;
    T *primero = nullptr, *siguiente = nullptr, *ultimo = nullptr;
    void append(T elemento){
        if(size == 0) {
            elementos[0] = elemento;
            primero = elemento;
        }
        else{
            siguiente = elemento;
            ultimo = elemento;
        }
        size++;
    }
};