Все технические форумы на одном сайте Удобный поиск информации с популярных форумов в одном месте
Вопрос: Ввести через консоль несколько переменных через пробел в одной строке

Всем привет. Я только учусь программировать, так что вопрос должен быть довольно несложным.

Мне нужно ввести через консоль несколько переменных через пробел в одной строке. Затем требуется сравнить их с ранее введенной переменной, посчитать сколько раз условие сравнения выполняются и вывести количество удачных исходов.

С вводом переменных я вроде как разобрался, а вот как переменные из массива сравнить с другой переменной не знаю. Для ввода переменных через консоль я использовал что-то вроде этого:

Код Java(TM) 2 Platform Standard Edition 5.0
1
2
3
4
int []sl = new int[1000];
for (int i = 0; i < sl.length; i++) {
sl[i] = input.nextInt();
}
Ответ: рад, что сам заметил) в будущем не стесняйся выкладывать код поподробнее
Вопрос: Как ввести в консоль три числа через пробел?

Напишите программу, которая, используя метод Console.ReadLine(), вводит строку, содержащую три числа через пробел — сумму, процентную ставку (в процентах) и срок вклада......

Подскажите, пожалуйста, как ввести в консоль три числа через пробел?
Ответ:
Как ввести в консоль три числа через пробел?
Эмм.. сори отсутствие буковки Ы просмотрел
Вопрос: Запуск программы через консоль

Что нужно сделать, чтобы программу запускать не через обычные input.txt и output.txt а через консоль?
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "stack.h"
 
 
 
 
 
int main()
{
    char a, s[1000], s1[1000] = {0};
    Stack *S;
    long long int g=0;
    int d, k = 0;
    struct list *p, *t;
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    S = create();
    scanf("%s", s);
    postf(s, s1, S);
    printf("%s", s1);
    printf("\n");
    schet(s1, &g, S);
    printf("%I64d", g);
    return 0;
}
Вот допустим программа (функции постф и счет написаны в другом файле).
Через инпут и аутпут все нормально работает, но нужно сделать, чтобы работало вроде как через консоль или что-то такое.
Ответ: Ну вроде бы как я понял, нужно чтобы эта консоль была вместо инпута и аутпута разом.
Т е и вводишь в нее значение, и она выдает ответ. А как запускать ее наверное без разницы.
Я немного не понял, а куда это все приписывать?)
Как мне объяснили, в main нужно добавить 2 функции argc и **argv, вот так вот как-то наверное
int main(int argc, char *argv[])
Но что дальше делать, как запускать через консоль я так и не разобрался.
Bash
1
2
gcc main.cpp -o main
./main
Вот это вот что такое и куда это прописывать вообще нужно)
Вопрос: как ввести строку через консоль?

Здравствуйте, подскажите, мне нужно ввести строку через консоль что задействовать метод, который выделен Синим цветом,
static void Main(string[] args)
{
string menu;
Console.WriteLine("Введите страну производитель на латинском языке");
menu = Console.ReadLine();
if (menu == Germany)
{
var catalog = new Catalog();
catalog.Tank();
var germanWeapons = catalog.FindByCountry("германия");
Console.WriteLine(string.Format("Найдено элементов: {0}", germanWeapons.Count));
for (int i = 0; i < germanWeapons.Count; i++)
{
Console.WriteLine("======================");
Console.WriteLine(germanWeapons[i].Name);
Console.WriteLine(germanWeapons[i].Country);
Console.WriteLine(germanWeapons[i].Gun);
Console.WriteLine(germanWeapons[i].Course);
Console.WriteLine("======================");


}
}
Ответ: а если обойтись без проверки и уменьшить код раз в 10:
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static void Main(string[] args)
{
    Console.WriteLine("Введите страну производитель на латинском языке");
    string country = Console.ReadLine();
    var catalog = new Catalog();
    catalog.Tank();
    var anyWeapons = catalog.FindByCountry(country);
    Console.WriteLine(string.Format("Найдено элементов: {0}", anyWeapons.Count));
    for (int i = 0; i < anyWeapons.Count; i++)
    {
       Console.WriteLine("======================");
       Console.WriteLine(anyWeapons [i].Name);
       Console.WriteLine(anyWeapons [i].Country);
       Console.WriteLine(anyWeapons [i].Gun);
       Console.WriteLine(anyWeapons [i].Course);
       Console.WriteLine("======================");
    }
}
Вопрос: Ввод через консоль

Всем привет,нужна помощь. Прога рисует треугольник... накладывает на него текстуру...поворачивает его на заданное кол-во градусов...и создает освещенный треугольник- по тем же введенным координатам... проблема в том, что координаты считываются со второго раза через консоль..с первого ничего не происходит(((что посоветуете??
Код

#if defined(UNICODE) && !defined(_UNICODE)
    #define _UNICODE
#elif defined(_UNICODE) && !defined(UNICODE)
    #define UNICODE
#endif

#include <tchar.h>
#include <windows.h>
#include <iostream>
#include <cmath>

using namespace std;
/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

HDC hdc;
HDC hCmpDC;
HBITMAP hBitmap;
static HDC memBit;
static BITMAP bm;

struct Tr
{
 POINT points[3];//3 точки треугольника  с координатами points[].x и points[].y
 int Ir[3];//красная составляющая трех точек треугольника
 int Ig[3];//зеленая составляющая трех точек треугольника
 int Ib[3];//голубая составляющая трех точек треугольника
} tr;

inline void swap(float &a, float &b)
{     float t;
      t = a;
      a = b;
      b = t;
}

void triangle(HDC hdc, int x1, int y1, int x2, int y2, int x3, int y3, int color)
{ // Упорядочиваем точки p1(x1, y1),p2(x2, y2), p3(x3, y3)
      if (y2 < y1) {
            swap(y1, y2);
            swap(x1, x2);
      } // точки p1, p2 упорядочены
      if (y3 < y1) {
            swap(y1, y3);
            swap(x1, x3);
      } // точки p1, p3 упорядочены теперь p1 самая верхняя осталось упорядочить p2 и p3
      if (y2 > y3) {
            swap(y2, y3);
            swap(x2, x3);
      }

      // приращения по оси x для трёх сторон треугольника
      float dx13 = 0, dx12 = 0, dx23 = 0;

      // вычисляем приращения в случае, если ординаты двух точек совпадают, приращения полагаются равными нулю
      if (y3 != y1) {
            dx13 = float (x3 - x1);
            dx13 /= y3 - y1;
      }
      else
      {
            dx13 = 0;
      }

      if (y2 != y1) {
            dx12 = float (x2 - x1);
            dx12 /= (y2 - y1);
      }
      else
      {
            dx12 = 0;
      }

      if (y3 != y2) {
            dx23 = float (x3 - x2);
            dx23 /= (y3 - y2);
      }
      else
      {
            dx23 = 0;
      }

      // "рабочие точки" изначально они находятся в верхней точке
      float wx1 = float (x1);
      float wx2 = wx1;

      // сохраняем приращение dx13 в другой переменной
      float _dx13 = dx13;

      // упорядочиваем приращения таким образом, чтобы в процессе работы алгоритмы точка wx1 была всегда левее wx2
      if (dx13 > dx12)
      {
            swap(dx13, dx12);
      }

      // растеризуем верхний полутреугольник
      for (int i = y1; i < y2; i++){
            // рисуем горизонтальную линию между рабочими точками
            for (int j = int(wx1); j <= int(wx2); j++){
                  SetPixel(hdc, j, i,  color);
            }
            wx1 += dx13;
            wx2 += dx12;
      }

      // вырожденный случай, когда верхнего полутреугольника нет надо разнести рабочие точки по оси x, т.к. изначально они совпадают
      if (y1 == y2){
            wx1 = float (x1);
            wx2 = float (x2);
      }

      // упорядочиваем приращения (используем сохраненное приращение)
      if (_dx13 < dx23)
      {
            swap(_dx13, dx23);
      }

      // растеризуем нижний полутреугольник
      for (int i = y2; i <= y3; i++){
            // рисуем горизонтальную линию между рабочими точками
            for (int j = int(wx1); j <= int(wx2); j++){
                  SetPixel(hdc, j, i,  color);
            }
            wx1 += _dx13;
            wx2 += dx23;
      }
}
void AreaGuro(Tr tr, float a1, float b1, float a2, float b2, float a3, float b3)
{
    double Ir1, Ir2, Ig1, Ig2, Ib1, Ib2;
    double x, y;
    double x1, x2, t1, t2, t;
    int R, G, B;

    tr.points[0].x = a1;
    tr.points[0].y = b1;
    tr.points[1].x = a2;
    tr.points[1].y = b2;
    tr.points[2].x = a3;
    tr.points[2].y = b3;
    tr.Ir[0] = 0; tr.Ir[1] = 255; tr.Ir[2] = 255;
    tr.Ig[0] = 0; tr.Ig[1] = 0; tr.Ig[2] = 0;
    tr.Ib[0] = 0; tr.Ib[1] = 0; tr.Ib[2] = 0;
//упорядочить вершины по y
 {    POINT temp;
    if(tr.points[0].y > tr.points[1].y)
    {
    temp = tr.points[0];
     tr.points[0] = tr.points[1];
     tr.points[1] = temp;
    }
    if(tr.points[1].y > tr.points[2].y)
    {
    temp = tr.points[1];
     tr.points[1] = tr.points[2];
     tr.points[2] = temp;
    }
    if(tr.points[0].y > tr.points[1].y)
    {
    temp = tr.points[0];
     tr.points[0] = tr.points[1];
     tr.points[1] = temp;
    }
 }

 for (y = tr.points[0].y; y < tr.points[1].y; y++) //закрашиваем линии от верхней к нижней
 {
     //точки пересечения линии(y) с границами грани(ac,ab)
     x1 = ((y - tr.points[0].y)/(tr.points[1].y - tr.points[0].y))*(tr.points[1].x - tr.points[0].x) + tr.points[0].x;
     x2 = ((y - tr.points[0].y)/(tr.points[2].y - tr.points[0].y))*(tr.points[2].x - tr.points[0].x) + tr.points[0].x;

     //интенсивности в точках пересечения линии(y) с границами грани
     if (tr.points[0].x == tr.points[1].x) continue;
     if (tr.points[0].x == tr.points[2].x) continue;
     t1 = (x1 - tr.points[1].x)/(tr.points[0].x - tr.points[1].x);
     t2 = (x2 - tr.points[2].x)/(tr.points[0].x - tr.points[2].x);

        Ir1=t1*tr.Ir[0] + (1-t1)*tr.Ir[1];
        Ir2=t2*tr.Ir[0] + (1-t2)*tr.Ir[2];

        Ig1=t1*tr.Ig[0] + (1-t1)*tr.Ig[1];
        Ig2=t2*tr.Ig[0] + (1-t2)*tr.Ig[2];

        Ib1=t1*tr.Ib[0] + (1-t1)*tr.Ib[1];
        Ib2=t2*tr.Ib[0] + (1-t2)*tr.Ib[2];

     if (x2 == x1) continue;
     if (x2 > x1)
     {
        //рисовать линию
        for(x = (int) x1; x<=(int) x2; x++)
        {
        //интенсивность в точке x
        t = (x2-x)/(x2-x1);
        R = int(t*Ir1 + (1-t)*Ir2);
        G = int(t*Ig1 + (1-t)*Ig2);
        B = int(t*Ib1 + (1-t)*Ib2);

        SetPixel(hdc, int(x),int(y),RGB(R, G, B));
        }
     }
     else
     {
        //рисовать линию
        for(x = (int)x1; x>=(int)x2; x--)
        {
        //интенсивность в точке x
        t = (x2-x)/(x2-x1);

        R = int(t*Ir1 + (1-t)*Ir2);
        G = int(t*Ig1 + (1-t)*Ig2);
        B = int(t*Ib1 + (1-t)*Ib2);

        SetPixel(hdc, int(x),int(y),RGB(R,G,B));
        }
     }
 }
for(y=tr.points[1].y; y<=tr.points[2].y; y++)
 {
     //точки пересечения линии(y) с границами грани(ac,bc)
     x1 = ((y-tr.points[1].y)/(tr.points[2].y-tr.points[1].y))*(tr.points[2].x-tr.points[1].x) + tr.points[1].x;
     x2 = ((y-tr.points[0].y)/(tr.points[2].y-tr.points[0].y))*(tr.points[2].x-tr.points[0].x) + tr.points[0].x;

     //интенсивности в точках пересечения линии(y) с границами грани
     if (tr.points[2].x == tr.points[1].x) continue;
     if (tr.points[0].x == tr.points[2].x) continue;
     t1 = (x1-tr.points[2].x)/(tr.points[1].x-tr.points[2].x);
     t2 = (x2-tr.points[2].x)/(tr.points[0].x-tr.points[2].x);

        Ir1=t1*tr.Ir[0] + (1-t1)*tr.Ir[1];
        Ir2=t2*tr.Ir[0] + (1-t2)*tr.Ir[2];

        Ig1=t1*tr.Ig[1] + (1-t1)*tr.Ig[0];
        Ig2=t2*tr.Ig[2] + (1-t2)*tr.Ig[0];

        Ib1=t1*tr.Ib[0] + (1-t1)*tr.Ib[1];
        Ib2=t2*tr.Ib[0] + (1-t2)*tr.Ib[2];

     if (x2 == x1) continue;
     if (x2 > x1)
     {
        //рисовать линию
        for(x = (int) x1; x<=(int) x2; x++)
        {
        //интенсивность в точке x
        t = (x2-x) / (x2-x1);

        R = int(t*Ir1 + (1-t)*Ir2);
        G = int(t*Ig1 + (1-t)*Ig2);
        B = int(t*Ib1 + (1-t)*Ib2);

        SetPixel(hdc, int(x),int(y),RGB(R,G,B));
        }
     }
     else
     {
        //рисовать линию
        for(x = (int) x1; x >= (int) x2; x--)
        {
        //интенсивность в точке x
        t = (x2-x)/(x2-x1);

        R = int(t*Ir1 + (1-t)*Ir2);
        G = int(t*Ig1 + (1-t)*Ig2);
        B = int(t*Ib1 + (1-t)*Ib2);

        SetPixel(hdc, int(x),int(y),RGB(R,G,B));
        }
     }
 }
}
void rotateTexture90 (HDC hdc, float x1, float y1, float x2, float y2, float x3, float y3, float Xmax, float Xmin, float Kx, float Ky)
{
        float xo;
        float yo;
        int gr;
        int t;

cout<<"Введите точку вращения 1? 2? 3?: ";
         cin>>t;

       if(t=1)
       {
           xo=x1;yo=y1;
       }
       if(t=2)
       {
           xo=x2;yo=y2;
       }
        if(t=3)
       {
           xo=x3;yo=y3;
       }

        cout<<"На сколько градусов повернуть треугольник?: ";
        cin>>gr;
int color = RGB(0,255,0);
        int color2 = RGB(200,200,200);

           if (gr > 360)
               gr = gr - 360;
               {
                triangle(hdc, x1, y1, x2, y2, x3, y3, color2);
                float sina = sin(gr * (M_PI / 180));
                float cosa = cos(gr * (M_PI / 180));
                //Sleep(0);
               float newx1=((x1 - xo) * cosa - (y1 - yo) * sina) + xo;
               float newy1=((x1 - xo) * sina + (y1 - yo) * cosa) + yo;
               float newx2=((x2 - xo) * cosa - (y2 - yo) * sina) + xo;
               float newy2=((x2 - xo) * sina + (y2 - yo) * cosa) + yo;
               float newx3=((x3 - xo) * cosa - (y3 - yo) * sina) + xo;
               float newy3=((x3 - xo) * sina + (y3 - yo) * cosa) + yo;

               // Упорядочиваем точки p1(x1, y1),p2(x2, y2), p3(x3, y3)
      if ( newy2 <  newy1) {
            swap( newy1,  newy2);
            swap( newx1,  newx2);
      } // точки p1, p2 упорядочены
      if ( newy3 <  newy1) {
            swap( newy1,  newy3);
            swap( newx1,  newx3);
      } // точки p1, p3 упорядочены теперь p1 самая верхняя осталось упорядочить p2 и p3
      if ( newy2 >  newy3)  {
            swap( newy2,  newy3);
            swap( newx2,  newx3);
      }
      // приращения по оси x для трёх сторон треугольника
      float dx13 = 0, dx12 = 0, dx23 = 0;

      // вычисляем приращения в случае, если ординаты двух точек совпадают, приращения полагаются равными нулю
      if ( newy3 !=  newy1) {
            dx13 = float ( newx3 -  newx1);
            dx13 /=  newy3 -  newy1;
      }
      else
      {
            dx13 = 0;
      }

      if ( newy2 !=  newy1) {
            dx12 = float ( newx2 -  newx1);
            dx12 /= ( newy2 -  newy1);
      }
      else
      {
            dx12 = 0;
      }

      if (y3 != y2) {
            dx23 = float ( newx3 -  newx2);
            dx23 /= ( newy3 -  newy2);
      }
      else
      {
            dx23 = 0;
      }

      // "рабочие точки" изначально они находятся в верхней точке
      float wx1 = float ( newx1);
      float wx2 = wx1;

      // сохраняем приращение dx13 в другой переменной
      float _dx13 = dx13;

      // упорядочиваем приращения таким образом, чтобы в процессе работы алгоритмы точка wx1 была всегда левее wx2
      if (dx13 > dx12)
      {
            swap(dx13, dx12);
      }

      // растеризуем верхний полутреугольник
      for (int i =(int)  newy1; i < (int) newy2; i++)
      {
            // рисуем горизонтальную линию между рабочими точками
            for (int j = int(wx1); j < int(wx2); j++)
            {
                float newx11 =((j - xo) * cosa + (i - yo) * sina) + xo;
             float newy11 =(-(j - xo) * sina + (i - yo) * cosa) + yo;
                SetPixel(hdc, j, i,  GetPixel(memBit, (int) (((newx11-Xmin) * Kx)), (int) ((newy11-y1) * Ky)));
            }
            wx1 += dx13;
            wx2 += dx12;
      }
      // вырожденный случай, когда верхнего полутреугольника нет надо разнести рабочие точки по оси x, т.к. изначально они совпадают
      if ( newy1 ==  newy2 &&  newx1 <  newx2)
        {
            wx1 = float ( newx1);
            wx2 = float ( newx2);
        }

      if ( newy1 ==  newy2 &&  newx1 >  newx2)
        {
            wx1 = float ( newx2);
            wx2 = float ( newx1);
        }
      // упорядочиваем приращения (используем сохраненное приращение)
      if (_dx13 < dx23)
      {
            swap(_dx13, dx23);
      }

      // растеризуем нижний полутреугольник
      for (int i = (int)  newy2; i < (int)  newy3; i++)
        {
            // рисуем горизонтальную линию между рабочими точками
            for (int j = int(wx1); j < int(wx2); j++)
            {
             float newx11 =((j - xo) * cosa + (i - yo) * sina) + xo;
             float newy11 =(-(j - xo) * sina + (i - yo) * cosa) + yo;
                SetPixel(hdc, j, i,  GetPixel(memBit, (int) (((newx11-Xmin) * Kx)), (int) ((newy11-y1) * Ky)));
            }
            wx1 += _dx13;
            wx2 += dx23;
        }
}

}
void texture(HDC hdc, float x1, float y1, float x2, float y2, float x3, float y3, float Xmax, float Xmin)
{
      // Упорядочиваем точки p1(x1, y1),p2(x2, y2), p3(x3, y3)
      if (y2 < y1) {
            swap(y1, y2);
            swap(x1, x2);
      } // точки p1, p2 упорядочены
      if (y3 < y1) {
            swap(y1, y3);
            swap(x1, x3);
      } // точки p1, p3 упорядочены теперь p1 самая верхняя осталось упорядочить p2 и p3
      if (y2 > y3) {
            swap(y2, y3);
            swap(x2, x3);
      }

      // приращения по оси x для трёх сторон треугольника
      float dx13 = 0, dx12 = 0, dx23 = 0;

      // вычисляем приращения в случае, если ординаты двух точек совпадают, приращения полагаются равными нулю
      if (y3 != y1) {
            dx13 = float (x3 - x1);
            dx13 /= y3 - y1;
      }
      else
      {
            dx13 = 0;
      }

      if (y2 != y1) {
            dx12 = float (x2 - x1);
            dx12 /= (y2 - y1);
      }
      else
      {
            dx12 = 0;
      }

      if (y3 != y2) {
            dx23 = float (x3 - x2);
            dx23 /= (y3 - y2);
      }
      else
      {
            dx23 = 0;
      }

      // "рабочие точки" изначально они находятся в верхней точке
      float wx1 = float (x1);
      float wx2 = wx1;

      // сохраняем приращение dx13 в другой переменной
      float _dx13 = dx13;
 // упорядочиваем приращения таким образом, чтобы в процессе работы алгоритмы точка wx1 была всегда левее wx2
      if (dx13 > dx12)
      {
            swap(dx13, dx12);
      }

      if (x1 > x2)
      {
          Xmax = x1;
          Xmin = x2;
          if (x1 < x3)
          Xmax = x3;
          if (x2 > x3)
          Xmin = x3;
      }
      else
      {
          Xmax = x2;
          Xmin = x1;
          if (x2 < x3)
          Xmax = x3;
          if (x1 > x3)
          Xmin = x3;
      }
      float Kx = bm.bmWidth/(Xmax - Xmin);
      float Ky = bm.bmHeight/(y3 - y1);

      // растеризуем верхний полутреугольник
      for (int i = y1; i < y2; i++){
            // рисуем горизонтальную линию между рабочими точками
            for (int j = int(wx1); j <= int(wx2); j++){
                  SetPixel(hdc, j, i,  GetPixel(memBit, (int) (((j-Xmin) * Kx)), (int) ((i-y1) * Ky)));
            }
            wx1 += dx13;
            wx2 += dx12;
      }

      // вырожденный случай, когда верхнего полутреугольника нет надо разнести рабочие точки по оси x, т.к. изначально они совпадают
      if (y1 == y2){
            wx1 = float (x1);
            wx2 = float (x2);
      }

      // упорядочиваем приращения (используем сохраненное приращение)
      if (_dx13 < dx23)
      {
            swap(_dx13, dx23);
      }

      // растеризуем нижний полутреугольник
      for (int i = y2; i <= y3; i++){
            // рисуем горизонтальную линию между рабочими точками
            for (int j = int(wx1); j <= int(wx2); j++){
                  SetPixel(hdc, j, i,  GetPixel(memBit, (int) (((j-Xmin) * Kx)), (int) ((i-y1) * Ky)));
            }
            wx1 += _dx13;
            wx2 += dx23;
      }
 rotateTexture90 (hdc, x1, y1, x2, y2, x3, y3, Xmax, Xmin, Kx, Ky);
}

//Ввод через консоль
void TrangleAll()
{
    SetConsoleOutputCP(1251);
    SetConsoleCP(1251);

        float x1=0;
        float y1=0;
        float x2=0;
        float y2=0;
        float x3=0;
        float y3=0;
        float Xmax=0;
        float Xmin=0;
        float Kx=0;
        float Ky=0;


          cout<<"Введите координаты первой точки: x =  ";
        cin>>x1;
        cout<<"y = ";
        cin>>y1;

        cout<<"Введите координаты второй точки: x =  ";
        cin>>x2;
        cout<<"y = ";
        cin>>y2;

        cout<<"Введите координаты третьей точки: x =  ";
        cin>>x3;
        cout<<"y = ";
        cin>>y3;

texture(hdc, x1, y1, x2, y2, x3, y3, Xmax, Xmin);
        Sleep(1500);
        AreaGuro(tr, x1, y1, x2, y2, x3, y3);

}

TCHAR szClassName[ ] = _T("CodeBlocksWindowsApp");
int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;/* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           _T("Code::Blocks Template Windows App"),       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           800,                 /* The programs width */
           500,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */

ShowWindow (hwnd, nCmdShow);
    UpdateWindow(hwnd);
PAINTSTRUCT ps;
HBITMAP hBmp, hbmp;
        hBitmap = (HBITMAP)LoadImage(NULL, _T("2.bmp"), IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
            GetObject(hBitmap, sizeof(bm), &bm);

            memBit = CreateCompatibleDC(hdc);
            SelectObject(memBit, hBitmap);
            ReleaseDC(hwnd, hdc);
    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {   PAINTSTRUCT ps;
    //HDC hCmpDC;
    HBITMAP hBmp, hbmp;
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
hdc = BeginPaint(hwnd, &ps);
HDC hdc = GetDC(hwnd);
loop:
//***************Вывод**************
TrangleAll();

            DeleteDC(hCmpDC);
            DeleteObject(hBmp);
            DeleteObject(hbmp);
            hCmpDC = NULL;

            EndPaint(hwnd, &ps);

}
    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)                  /* handle the messages */
    { case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

Ответ:
ну так может ему и задать вопрос сей....
Вопрос: Вычисление значения математической формулы введённой через консколь

Через консоль я заполняю массив char какой-то неизвестной заранее формулой, например 2+2. Так вот как мне посчитать значение этой формулы? Я знаю, что можно сделать это, создав функции каждой операции, но неужели нельзя сделать это проще?
Ответ: macewindujedii,
Вопрос: Работа с вводом через консоль Scanner

добрый день.
как человек, только начинающий изучение, буду признателен совету, как правильно реализовать подобие логина через консоль
имеется:
Код Java(TM) 2 Platform Standard Edition 5.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.Scanner;
 
public class InputWorker {
    public static void inputLogin(){
        Scanner sc = new Scanner(System.in);
            System.out.println("# Добро пожаловать");
            System.out.println("# Пожалуйста войдите или и зарегистрируйтесь");
            System.out.println("# 1 - Войти");
            System.out.println("# 2 - Зарегистрироваться");
            System.out.print("# Введите ответ: ");
 
            if (sc.hasNextInt(1)) {
                System.out.println("//method for loging");
            } else if (sc.hasNextInt(2)) {
                System.out.println("// method for register");
            } else {
                System.out.println("Ошибка! Наверное, Вы ввели неверный ответ. Попробуйте ещё раз");
            }
    }
}
в первом случаи вызвать "метод для регистрации" не выходит в принципе
так же пробовал так

import java.util.Scanner;

Код Java(TM) 2 Platform Standard Edition 5.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class InputWorker {
    public static void inputLogin(){
        Scanner sc = new Scanner(System.in);
            System.out.println("# Добро пожаловать");
            System.out.println("# Пожалуйста войдите или зарегистрируйтесь");
            System.out.println("# 1 - Войти");
            System.out.println("# 2 - Зарегистрироваться");
            System.out.print("# Введите ответ: ");
            int answer = sc.nextInt();
            if (answer ==1) {
                System.out.println("//method for loging");
            } else if (answer ==2) {
                System.out.println("// method for register");
            } else {
                System.out.println("Ошибка! Наверное, Вы ввели неверный ответ. Попробуйте ещё раз");
            }
    }
}
Хочется что бы пользователь имел возможность выбора, а так же если вводиться текст или значение отличное от 1или2 - выводилось сообщение об ошибке и возвращало к выбору ответа.

буду признателен за наводки на верное направление
Ответ: всем спасибо. вопрос решил
Вопрос: Консоль и Qt. Возможность работать как через консоль так и через графический интерфейс

Может кто-то знает... Как в одном и том же приложении совместить возможность запуска и через консоль и через разработанный через Qt графический интерфейс? Чтобы можно было запускать и так и так...Как это совместить?
На данный момент есть приложение, которое может архивировать и дезархивировать файлы и через консоль и через графический интерфейс. Изменения как будет все работать есть только в main.cpp. Если закоментировать одно, то работает через консоль и наоборот. А как совместить?
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include "zipper.h"
#include <QtWidgets/QApplication>
#include <ctime>
 
int main(int argv, char *argc[])
{
setlocale(LC_ALL,"Russian");
QApplication a(argv, argc);
    
Zipper w;
w.show();
    
/*  Node Wood;
    Hoffman Нoff;
        
    std::cout<<std::endl<<"######################## ZIPPER ########################"<<std::endl<<std::endl;
 
    if(argv>1)
    {//-pack -files C:\test\text1.txt C:\test\text2.txt C:\test\text3.txt -path C:\test -name proba
        //  -unpack -files C:\test\proba.bin -path C:\test\unpack
        std::vector<std::string> files;
        std::string path = "";
        std::string name ="";
        bool flag_fs = false, flag_path = false, flag_name= false;
        char type[7];
        memset(type,0,7);
        for(int i=1;i<argv;i++)
        {
            if(strcmp(argc[i],"-pack")==0) { strcpy(type,"pack"); flag_fs=flag_path=flag_name=false;}
            if(strcmp(argc[i],"-unpack")==0) { strcpy(type,"unpack"); flag_fs=flag_path=flag_name=false;}
            if(strcmp(argc[i],"-path")==0) {flag_path=true; flag_fs=false; flag_name= false; continue; }
            if(strcmp(argc[i],"-files")==0) {flag_fs=true; flag_path=false; flag_name= false; continue; }
            if(strcmp(argc[i],"-name")==0) {flag_name= true;flag_fs=false; flag_path=false; continue; }
 
            if(flag_path) {path.assign(argc[i]); }
            if(flag_fs) files.push_back(std::string(argc[i]));
            if(flag_name) {name.assign(argc[i]); }
        }
        Package *zip = new Package(files,path,name);
        if(strcmp(type,"pack")==0)
        {
            zip->Packaging();//упаковка файлов в один
            Нoff.archiving(zip,Wood,Нoff);
        }
        if(strcmp(type,"unpack")==0)
        {               
            Нoff.unСompression(Wood.counting,files,zip);//разархивация
            zip->Unpacking(zip->unhoff_bin_file);
        }
    }
    else std::cout<<"Параметры -pack/-unpack , -files, -path обязательны!"<<std::endl;
    std::cout<<std::endl<<"########################################################"<<std::endl<<std::endl;
    std::cout << "Время выполнения = " << clock()/1000.0 << endl; // время работы программы
    
    system("pause");
    return 0;*/
    
    return a.exec();
}
Ответ: lenarano, в Qt 5.2 добавили свой парсер командной строки.
C++ (QT)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    setupApplication(&a);
 
#if QT_VERSION_COMBINED >= VERSION_COMBINE(5, 2, 0)
    CommandLine::CmdLine cmd(a.arguments());
    if (cmd.needProcess()) // if console mode
    {
        return cmd.process();
    }
#endif
 
    // gui mode
    MainWindow w;
    w.show();
    return a.exec();
}

CmdLine в classes/cmdline/cmdline.cpp
Вопрос: Как сравнить значение введенное в консоли со значением в файле?

как сравнить значение введенное в консоли со значением в файле, к примеру с консоли вводится какое то слово или число, после чего идет поиск в файле точно такого же слова или числа.
Ответ:
C#
1
2
3
4
5
6
7
8
9
10
11
12
13
string searchText = Console.ReadLine();
 
int rowNumber = 1;
var fileLines = File.ReadLines("path_to_your_file");
foreach (string fileLine in fileLines)
{
   if (fileLine.IndexOf(searchText) != -1)
   {
       Console.WriteLine("Значение {0} присутствует в файле в строке {1}", searchText, rowNumber);
       break;
   }
   rowNumber++;
}
Вопрос: Определить, является ли введенная с консоли строка палиндромом

Программа определяет, является ли введенная с консоли строка симметричной. Например, строка «казак» симметрична. Её можно одинаково прочитать слева направо и справа налево.
Ответ:
Pascal
1
2
3
4
5
6
7
n:=length(s);
k:=0;
i:=1;
while(i<=n div 2)and(k=0) do
if s[i]<>s[n-i+1 then k:=1 else inc(i);
if k=0 then write('Симметрична')
else  write('Не симметрична');