Hola a todos. Hace mucho que no hago alguna aportación por aquí, y por cutre que sea, voy a poner un selector de opciones, en el que no hay que elegir el número de la opción, sinó hay que mover el marcador con W y S. Bueno, aquí va:

#include <iostream>
#include <vector>
#include <conio.h>
using namespace std;
 
class options{
    vector<string> _options;
    string _title;
 
    void coutTitle()const{
        if(_title.size()==0) return;
        vector<string> v;
        string t = _title;
        while(t.size()>80){
            v.push_back(t.substr(0,80));
            t.erase(0,80);
        }
        v.push_back(t);
        while(v.size()>1){
            cout << v[0];
            v.erase(v.begin());
        }
        cout << string((80-v[0].size())/2,' ') << v[0] << endl << endl;
    }
 
public:
    options(){}
    options(string title):_title(title){}
    options(const options& o):_options(o.getOptions()),_title(o.getTitle()){}
    void setTitle(string title){
        _title = title;
    }
    string getTitle()const{
        return _title;
    }
    vector<string> getOptions()const{
        return _options;
    }
    string getOption(size_t i)const{
        if(i<_options.size()) return _options[i];
        return "";
    }
    void addOption(string option){
        _options.push_back(option);
    }
    void addOptions(const vector<string>& v){
        for(int i=0; i<v.size(); i++)
            _options.push_back(v[i]);
    }
    void setOptions(const vector<string>& v){
        _options = v;
    }
    int show()const{
        int index = 0;
        char c = 0;
        while(c!='\r' && c!='\n'){
            system("cls");
            coutTitle();
            for(int i=0; i<_options.size(); i++){
                cout << '[' << (i==index?'X':' ') << "] " << _options[i] << endl;
            }
            c = getch();
            if((c=='w' || c=='W') && index>0)
                --index;
            if((c=='s' || c=='S') && index<_options.size()-1)
                ++index;
        }
        return index;
    }
};
 
int main(){
    options op;
    op.setTitle("Que querrias ser en otra vida?");
    op.addOption("Un Dios.");
    op.addOption("Un gobernador.");
    op.addOption("Un pensador.");
    op.addOption("Un trabajador.");
    op.addOption("Un esclavo.");
    cout << endl << endl << op.show();
}

Se le pone un titulo, se le agregan las opciones, y se invoca .show(). Show retorna el índice de la opcion elegida.


Utilizo la función system("cls") y getch(). Quién las quiera cambiar por otras, es libre de hacerlo, este código no tiene copyright xD

Usé getch() de conio.h porque es la más rápida y sencilla.

Jeje esto lo hice hace unos 4 años, pero lo hice a lo cutre con 2 solas opciones (y me costó). Ahora, años después, he visto lo terriblemente sencilo que es jaja.

"Una vez más, la experiencia marca la aptitud."

Saludos, espero que a alguien le sea útil :p

Hoy sobre las 13:00 ha comenzado el concurso de programación de Tuenti.
http://contest.tuenti.net
Avisi, para quién no lo haya visto y quiera participar

Enviado desde mi ST21i mediante Tapatalk

Hola, tengo la duda de cómo conseguir los argumentos pasados al programa.
La cantidad de argumentos, seguido de la ruta del programa y de las demás cadenas.
Tenía entendido que se almacenaban en el stack, pero ahí no los ví, así que pregunto por aquí :3

PD: Uso FASM

Hola, tenía la duda de si se puede en C++, (sin la biblioteca Windows.h), hacer capturas de pantalla, y guardarlas de la forma que sea.

¿Alguien sabe algo?

Como dato, estoy trabajando con SFML, pero creo que este no tiene nada para ello.

Si alguien sabe que diga, gracias

Hola, tengo un problemilla.

fstream a("asd.dat");
a << "hola";

En general, es eso. El problema es que si el archivos está vacío, no escribe nada.

¿Sabéis algo al respecto?

Holas, hoy me dió por colgar una clase, que simula la pila de ASM. Se suele hacer mucho, pero la voy a postear:

class pila{
private:
    int data;
    int length;
    pila *next;
    void nullNext(){next = nullptr;}
 
public:
    pila(){data = -1; length = 0; next = nullptr;}
    pila(pila *p){data = p->data; length = p->length; next = p->next;}
    ~pila(){while(next != nullptr) pop();}
    int getData(){return data;}
    int getLength(){return length;}
    pila *getNext(){return next;}
    bool pop(){
        if(next != nullptr){
            data = next->data;
            --length;
            pila *temp = next;
            next = next->next;
            temp->nullNext();
            delete temp;
            return true;
        }
        return false;
    }
    void push(int d = 0){
        next = new pila(this);
        ++length;
        data = d;
    }
};

Si a alguien le gusta, que la use. Si alguien le ve algún bug/error/inconveniente, que lo diga.

La pila, guarda 3 valores: La direccion de la siguiente de la pila (*next); el dato de ese segmento (dato); la cantidad o longitud de la pila (length).

Ciao :3

Mi pregunta es más que nada por curiosidad. El operador "+" de enteros por ejemplo, ¿cómo está definido de raiz? ¿O es una función ya a bajo nivel?
Por ejemplo, el operador * podría ser un bucle for, sumando "a" veces "b".
¿Pero el "+"?

Afirmación: Solo es posible divertirse con un juego que tú mismo has creado, si en ese juego hay componentes aleatorio. Por ejemplo, en uno de lucha, ataque aleatorio. O pensamiento de IA algo aleatorio.

¿Que opinais de eso?

Comentad lo que veais oportuno.
Yo me he divertido con un juego que hice, pero ese juego contiene "rand()" en su código, y varios.

Según dicen los diccionarios, y en concreto este de aquí:

Ahora supongamos que tenemos una máquina, que trabaja en una fábrica. Que ella sola hace máquinas iguales a ella. Suelda, monta, etc. Ademas, (y esto es algo absurdo), se suelda cada rato un trozo de metal a si mismo.

1)Podríamos decir que crece, ya que aumenta su tamaño gracias al metal.
2)Se reproduce, pues crea otras máquinas como ella.
3)Responde a estímulos, porque tiene sensores de movimiento, de calor, etc.

Me gustaría que alguien me desmienta esta afirmación: Esta máquina es un ser vivo.

PD: Claramente no soy tonto, sé que no es un ser vivo xD pero me parece interesante, ya que si no se desmiente, estaríamos diciendo que los diccionarios están mal redactados (?)

Yo programo C++ en Windows 7. Programo en consola, principalmente porque no se mucho visual ni de API's xD

La duda es...
 Si, programando en consola, cambio los -system("cls");- y -system("pause");- (supongo que una mala costumbre mía), y pongo comandos de la librería estandar, ¿sería portable a otros Windows, Unix, Apple, y diversos sistemas?

EDITO: Busco la forma de borrar la pantalla de consola sin usar system("cls"), clrscr(), ni escribir 100 saltos de linea.