Buenas, estoy con un ejercicio ( voy por partes ahora mismo no estoy atacando el problema como tal), mi idea es controlar lo que el usuario mete, con una condición guardo 8 0 o 1 si introduce algo que no es, lo siguiente que introduzca el usuario quiero macharlo ( con el fin de no guardar cosas que luego tendría que quitar), y si el usuario introduce un negativo corte pero la cosa es que no consigo que la función mía imprima para ver si lo tengo bien mi vector alguien me podría decir por que?


//  Implemente un programa que lea desde teclado valores de bits ( ceros y unos como enteros)
//  ,ignorando el resto de números positivos. El programa terminará cuando se lea un valor
//  negativo. Cada 8 bits leídos, el programa calculará el número entero que representa
//  y lo transformará en el carácter(char) correspondiente. El primer bit leído es el más
//  significativo. Si el carácter corresponde a una letra mayúscula o minúscula, lo
//  mostrará por pantalla. En caso contrario, lo sumará a un contador OTROS. Al final, el
//  programa debe mostrar el porcentaje de letras y OTROS símbolos leídos.
//  Si al terminar no se ha leído un bloque entero de 8 bits, no se imprimira el carácter


#include <iostream>
using namespace std;

int const MAX_VECTOR = 30;

void imprimir(char _vector[MAX_VECTOR]);

int main() {
    //  Variables y constantes
    int num_introducido = 0;
    char vector[30] = {0};
    int contador = 0;
    int contador_vector = 0;
   
    //  Desarrollo del programa
    do{
        cout << "Introduce un bit: " << endl;
        cin >> num_introducido;
        if(num_introducido >= 0 && num_introducido <= 1){
            vector[contador] += num_introducido;
            contador_vector++;
        }
        if(contador_vector < 8){
            contador++;
        }
    }while(num_introducido >= 0);
   
    imprimir(vector);
   
    return 0;
}

void imprimir(char _vector[MAX_VECTOR]){
    for(int i = 0; i < MAX_VECTOR; i++){
        cout << _vector << endl;
    }
}

llevo ya mas de dos horas y nada os pongo lo que tengo, la idea es con una matriz que yo he definido en el main eliminar los números negativos de dentro:


// Realizar un módulo para eliminar todos los valores negativos de un vector de
//  enteros. Hacedlo sobre el mismo vector, y sin usar vectores auxiliares.
//  Por ejemplo, después de aplicar dicho módulo al vector (2,-3,1,8,5), éste debe
// quedarse con (2,1,8).

#include <iostream>
using namespace std;

void adios_negativos(int _vector[], int _longitud_vector);

int main() {
    //  Variables y constantes
    int longitud_vector = 8;
    int vector[] = {-1, -2, 3, 4, -7, 8, 9, -11};
   
    //  Desarrallo del programa
    adios_negativos(vector, longitud_vector);
    for(int k = 0; k < longitud_vector; k++){
        cout << vector[k];
    }
    return 0;
}

void adios_negativos(int _vector[], int _longitud_vector){
    for(int i = 0; i < _longitud_vector; i++){
        if(_vector < 0){
            for(int j = i; j < _longitud_vector; j++){
                _vector[j] = _vector[j+1];
            }
        }
    }
}

Buenas estoy haciendo un ejercicio simple de clases ( solo hemos dado el class nada de programacion orienta a objetos) la cosa es que aunque no tengo clase hasta el viernes practicas y el jueves es teoria ( que lo explicara con ejemplo y demas mejor) estoy realizando los ejercicos de la relacion ya, pero no entiendo que me falla. Paso codigo con el enunciado y demas

-- Solo quiero que me ayudeis con el apartado A el area los demas quiero yo calentarme la cabeza ( aunque sabiendo hacer el a los demas tienen que salir mas o menos igual).

//  16.Establecer una definición de una clase que represente el tipo de dato
//  rectángulo. A partir de la definición propuesta construir:
//  a. Un método que calcule el área del rectángulo.
//  b. Un método que calcule el perímetro del rectángulo.
//  c. Un método que reciba otro rectángulo e indique cuál es el mayor (el de mayor área).
//  d. Un método que nos diga si 2 rectángulos son iguales (tienen el mismo área Y el mismo
//  perímetro).
//  e. Un método que intercambie los valores entre el rectángulo del objeto y otro objeto rectángulo
//  pasado como argumento.

#include <iostream>
using namespace std;

class Rectangulo{
    private:    //  Atributos
        int ladoa, ladob; // lados del rectangulo
    public:     //  Metodos
        Rectangulo(int, int);   //  Constructor de la clase
        void area();
        void perimetro();
};
//  Constructor nos sirve para inicialziar los atributos
Rectangulo::Rectangulo(int _ladoa, int _ladob){
    ladoa = _ladoa;
    ladob = _ladob;
}

int Rectangulo::area(int ladoa, int ladob){
    return area;
}

int main() {
    //  Variable y constantes
    int ladoA = 0, ladoB = 0, area = 0;
   
    //  Entrada del program
    do{
    cout << "Introduce el valor del ladoA: " << endl;
    cin >> ladoA;
    cout << "Introduce el valor del ladoB: " << endl;
    cin >> ladoB;
    }while(ladoA <= 0 || ladoB <= 0);
   
    //  Desarrollo del programa
   
    /*
    Rectangulo a(ladoA,ladoB);
    area = a.area(ladoA, ladoB);
    */
   
   
   
    return 0;
}

Llevo todo el dia con el ejercicio y no encuentro la forma.
Ahora mismo consigo tener el 1 15 y el 153 pero no encuentro la maldita forma de cuando salga 15 % 10, y cuando salga 153 % 100, sin utilizar un if,

Podeis darme un empujón o alguna idea de como hacerlo¿?

//  22. Un número entero de n dígitos se dice que es narcisista si se puede obtener como la suma de
//  las potencias n-ésimas de cada uno de sus dígitos. Por ejemplo 153 y 8208 son números narcisistas
//  porque 153 = 13 + 53 + 33 (153 tiene 3 dígitos) y 8208 = 84 + 24 + 04 + 84 (8208 tiene 4 dígitos).
//  Construir un programa que, dado un número entero positivo, nos indique si el número es o no
//  narcisista.
//  Finalidad: Ejercitar los bucles. Dificultad Media.
 
#include <iostream>
#include <cmath>
using namespace std;
 
int main() {
    //  Variables y constantes
    int numero_introducido = 0, numero_backup = 0, potencia = 0, resultado = 0, divisor = 100000, resultado_final = 0;
   
    //  Entrada del programa
    do{
        cout << "Introduce un numero: " << endl;
        cin >> numero_introducido;
        cin.clear();
    }while(numero_introducido <= 0);
   
    //  Resolucion del programa
    numero_backup = numero_introducido;
    while(numero_backup != 0){
        numero_backup /= 10;
        potencia++;
    }
    numero_backup = numero_introducido;
    while(numero_backup != 0){
        resultado = numero_backup / divisor;
        cout << resultado << endl;
        if(resultado != 0 && resultado > 0){
            resultado_final = resultado_final + pow(resultado, potencia);
        }
        divisor /= 10;
        cout << resultado_final << endl;
    }
   
    return 0;
}

Pues eso queria saber si tenéis pdf sobre como programar para que mis programas no tenga fallos de seguridad, y bueno ahora que estoy empezando me gustaría empezar a implementar la forma de programar seguro desde ya.

También vendría bien algunos consejos para evitar fallos comunes desbordamiento de buffer... ( ya he visto los post de c++ pero me gustaría saber mas)

Bueno estaba realizando ejercicios y ahora que acabo de terminarlo y antes de seguir con los demás quiero saber como mejorarlo ( voy a mirar la forma de hacerlo con un bucle en vez de tanto if, y la otra duda es cuando meto mas dígitos en el entero de que lo que soporta ejemplo 99999999999999999, el programa ( al menos a mi ) entra en bucle y se queda bloqueado alguna forma de solucionarlo ( no tendría por que hacerlo pero así voy aprendiendo).

Paso código:

//  21. Un número entero n se dice que es desgarrable (torn) si al dividirlo en dos partes
//  cualesquiera izda y dcha, el cuadrado de la suma de ambas partes es igual a n. Por ejemplo,
//  88209 es desgarrable ya que (88 + 209)2 = 88209; 81 también lo es ya que 81 =
//  (8+1)2.Cread un programa que lea un entero ne indique si es ono desgarrable.
//  Finalidad: Ejercitar los bucles. Dificultad Baja.

#include <iostream>
#include <cmath>
using namespace std;

int main() {
    //  Variables y constantes
    int numero_introducido = 0, contador = 1, cifra1 = 0, cifra2 = 0, cifra3 = 0, cifra4 = 0, cifra5 = 0, cifra6 = 0, numero_backup = 0, operado = 0, cifra_total = 0, concatenacion1 = 0, concatenacion2 = 0;
   
    //  Entrada del programa
    do{
    cout << "Introduzca un numero para comprobar si es desgarrable: " << endl;
    cin >> numero_introducido;
    }while(numero_introducido > 999999);
    numero_backup = numero_introducido;
   
    //  Resolucion del programa
    while (numero_introducido / 10 > 0){
        numero_introducido = numero_introducido / 10;
        contador++;
    }
    cout << "Cifras del numero introducido son: " << contador << endl;
    if(contador == 1){
        cout << "El numero no es desgarrable: " << numero_introducido << endl;
    }
    else if (contador == 2){
        //  Con el algoritmo de la division a = b+c + r
        //  Cociente y resto
        cifra1 = numero_backup / 10;
        cifra2 = numero_backup % 10;
        cifra_total = cifra1 + cifra2;
        operado = pow(cifra_total, 2);
        if(numero_backup == operado){
            cout << "El numero: " << numero_backup << " es un numero desgarrable. " << endl;
        }
        else{
            cout << "No es un numero desgarrable" << endl;
        }
    }
    else if (contador == 3){
        cifra1 = numero_backup / 100;
        cifra2 = (numero_backup % 100) / 10;
        cifra3 = numero_backup % 10;
        concatenacion1 = (cifra1 * 10) + cifra2;
        cout << concatenacion1 << endl;
        concatenacion2 = cifra3;
        cout << concatenacion2 << endl;
        cifra_total = concatenacion1 + concatenacion2;
        operado = pow(cifra_total,2);
        if (numero_backup == operado){
            cout << "El numero: " << numero_backup << " es un numero desgarrable. " << endl;
        }
        else{
            cout << "No es un numero desgarrable." << endl;
        }
    }
    else if (contador == 4){
        cifra1 = numero_backup / 1000;
        cifra2 = (numero_backup % 1000) / 100;
        cifra3 = (numero_backup % 100) / 10;
        cifra4 = (numero_backup % 10);
        concatenacion1 = (cifra1 * 10) + cifra2;
        concatenacion2 = (cifra3 * 10) + cifra4;
        cifra_total = (concatenacion1) + (concatenacion2);
        operado = pow(cifra_total, 2);
        if (numero_backup == operado){
            cout << "El numero: " << numero_backup << " es un numero desgarrable. " << endl;
        }
        else{
            cout << "No es un numero desgarrable." << endl;
        }
    }
    else if (contador == 5){
        cifra1 = numero_backup / 10000;
        cifra2 = (numero_backup % 10000) / 1000;
        cifra3 = (numero_backup % 1000) / 100;
        cifra4 = (numero_backup % 100) / 10;
        cifra5 = (numero_backup % 10);
        concatenacion1 = (cifra1 * 10) + cifra2;
        concatenacion2 = (cifra3 * 100) + (cifra4 * 10) + cifra5;
        cifra_total = concatenacion1 + concatenacion2;
        operado = pow(cifra_total, 2);
        if (numero_backup == operado){
            cout << "El numero: " << numero_backup << " es un numero desgarrable. " << endl;
        }
        else{
            cout << "No es un numero desgarrable. " << endl;
        }
    }
    else if (contador == 6){
        cifra1 = numero_backup / 100000;
        cifra2 = (numero_backup % 100000) / 10000;
        cifra3 = (numero_backup % 10000) / 1000;
        cifra4 = (numero_backup % 1000) / 100;
        cifra5 = (numero_backup % 100) / 10;
        cifra6 = (numero_backup % 10);
        concatenacion1 = (cifra1 * 100) + (cifra2 * 10) + cifra3;
        concatenacion2 = (cifra4 * 100) + (cifra5 * 10) + cifra6;
        cifra_total = concatenacion1 + concatenacion2;
        operado = pow(cifra_total, 2);
        if (numero_backup == operado){
            cout << "El numero: " << numero_backup << " es un numero desgarrable. " << endl;
        }
        else{
            cout << "No es un numero desgarrable.  " << endl;
        }
    }
    return 0;
}

Bueno en unos dias me voy fuera a una residencia universitaria y bueno necesitare internet y tenia pensado contratar internet ( por usb para mi portatil) creo que solo esta la opcion de 4g y queria saber vuestra experiencia con contratar internet para el portatil con un usb y demas ya que en la residencia no esta permitido creo la instalacion de internet personal ( hay uno para toda la residencia, y paso de meterme en ella) asi que que me recomendais o vuestra experiencia si habeis tenido que trabajar fuera y tenias que usar un pincho usb para trabajar en remoto

Dejo por aqui un post que puede ayudar a gente

 Han  implementado en reaver una nueva funcionalidad: -p with arbitrary string

-p, --pin=<wps pin>             Use the specified pin (may be arbitrary string or 4/8 digit WPS pin)

La opción -p permite mandar el PIN WPS que queremos
  Ahora permite mandar lo que queremos (literalmente)
  Incluso un PIN vació.
  Puede parecer absurdo... Pero da resultados contra los PA que tienen el modo WPS PIN incorrectamente configurado.
  Varios fabricantes "deshabilitan" el modo PIN con un truco barato: Declaran su variable para el PIN sin atribuirle valor.
 Podéis ver en este vídeo como crackeo un router ZTE del ISP español Jazztel mandando un PIN "en blanco" con reaver 1.6beta

 Este método nuevo ha permitido romper varios modelos de ZTE: ZTE H108N, ZTE H218N y ZTE H298N
  Funciona también contra la box NB6V-FXC del ISP francés SFR
  El método fue originalmente encontrado contra un Huawei HG658c
Algo de lectura sobre esta nueva vulnerabilidad WPS:
     * https://hg658c.wordpress.com/2015/06/20/obtaining-the-wifi-password-in-a-few-seconds-usin : El tema (en inglés) dónde se desvela por primera vez la brecha
     * https://github.com/t6x/reaver-wps-fork-t6x/wiki/Introducing-a-new-way-to-crack-WPS:-Option--p-with-an-Arbitrary-String : El articulo ( en inglés ) explicativo de la wiki de reaver
     * https://www.wifi-libre.com/topic-835-todo-sobre-la-brecha-pin-null-contra-pa-zte-de-jazztel.html : El tema ( en español ) sobre la explotación de la brecha contra los routers ZTE que se usan en España.

Hoy en el blog de Christian Haschek leía una curiosa contramedida contra escáneres de vulnerabilidades web automáticos. Se trata de servir una bomba zip (en formato gzip para que lo "entiendan" los navegadores web) para que, cuando el servidor detecte actividad de una estas herramientas automáticas, envíe el archivo para que sea procesado y agote los recursos (memoria y disco) de la máquina del atacante.

http://www.hackplayers.com/2017/07/defiende-tu-sitio-web-con-bombas-zip.html

Dejo el link de la noticia:
http://blog.segu-info.com.ar/2017/07/crackean-rsa-1024-bit-en-gnupg-por-un.html