Anonymní profil Půdní tvor – Programujte.com

Programuješ-li pod Windows, mrkni sem: http://programujte.com/forum/vlakno/18910-gotoxy/

Prodej knih ukončen

Ahoj,

nevím proč máš v struktuře Pair tolik věcí jako souřadnice a tak, zbytečně si to komplikuješ. Tady jednoduše stačí dvě dvourozměrné pole bool, jedno pole pro současnou generaci, druhé pro následujíci, po výpočtu následující generace ty pole prohodíš a bude to připravené na výpočet další generace.

Taky bych oddělil samotný výpočet od zobrazení, rozhodně je v programování dobrým zvykem oddělit každou ucelenou část kódu která dělá něco co se "dá nazvat" na své místo (do vlastní funkce), Snáze se to pak ladí, snáze se izoluje případná chyba, celkově je to srozumitelnější. V jedný dlouhý nudli která dělá všechno možný se pořádně nevyznáš. A někdo jiný to těžko bude chtít luštit když se v tom nevyznáš ani ty a to si to psal. :-)

Mohlo by to vypadat třeba nějak takto:

void Game::Play()
{
  while (...) {
    ShowCurrentGen()
    CalcNextGen();
    SwapGen();
    Wait(...);
  }
}

int main(...)
{
  Game game;

  game.Init();

  game.Play();

  return 0;
}

V příkazovém řadku na to příkaz není. No, protože mám často otevřených víc oken a zavřel jsem si taky kolikrát omylem něco co jsem opravdu nechtěl, tak jsem inspirován tvým dotazem udělal utilitku zavrit_off, která ten příkaz Zavřít u vybraného okna podle textu v titulku vypíná a hodil jsem ji na web puter.wz.cz

Na Codeproject je o tom tip s ukázkovým zdrojovým kódem (ale v C#) :

http://www.codeproject.com/Tips/159307/Count-Number-of-Unique-Colors-in-an-Image

Možná budu offtopic :

Pod Windows existuje možnost vypnout čekani na Enter a vypnout echo vstupu na obrazovku :

#include <stdio.h>
#include <windows.h>

int main(int argc, char* argv[])
{
#if 1
  // Vypne navraceni z getchar teprve po Enter, 
  // getchar se bude vracet ihned po precteni nejakeho znaku, 
  // bez jeho echa na obrazovku
  HANDLE handle = GetStdHandle(STD_INPUT_HANDLE); 
  DWORD mode;
  GetConsoleMode(handle, &mode);
  mode &= ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT); 
  SetConsoleMode(handle, mode);
#endif

  int c;
  while ((c = getchar()) != 'Q' && c != 'q') {
    printf("stiskl si %c\n", (unsigned char) c);
  }

  printf("Konec\n");

  return 0;
}

viz dokumentace SetConsoleMode a GetConsoleMode

To je zase nějaká školní úloha. Nebudem ti tu přece psát kuchařku co máš kde jak udělat.
Tu chybu na kterou si se ptal máš opravenou. Pár rad i mimo původní otázku jsi tu dostal.
Krokuj si to jestli to dělá co má, zkus na to přijít sám. Na co přijdeš sám má pro tebe stokrát vyšší hodnotu a budeš si to pamatovat. Teprve když si nebudeš s nějakou konkrétní věcí či chybou vědět rady se ozvi. Když to jasně specifikuješ, a problémový zdrojový kód do přízpěvku vložíš tlačítkem "vložit zdrojový kód", lidi ti jistě rádi pomůžou. V tomhle dlouhém, nepřehledném kódu má málokdo chuť se hrabat a hledat kde by mohl být problém.

Hodně zdaru.

Jo, jak říká KIIV. A tu realokaci máš taky podivnou, vůbec nezvětšuješ to místo, jen ho realokuješ se stejnou velikostí a ještě za tím vtipně poc += 100:

p=(clovek*) realloc(p,100*sizeof(clovek));
                                  poc+=100;

Kód děs běs, budu mít z toho noční můry. :)

v fscanf máš 6x %s ale jen 4 ukazatele kam se ty položky mají uložit, zbytek pujde kdovikam a proto to vyhazuje tu chybu:

fscanf(r,"%s %s %s %s %s %s\n",p[i].meno,p[i].priezv,p[i].narod,p[i].mesto);

hoď sem ještě tu funkci txt_citaj() jak psal liborb

#7 Peterop

To bylo upozornění čeho jsem si náhodou všiml. Ne.
 

Pozor, na několika místech překračuješ meze toho pole p které si v reset() vytváříš:

p=(clovek*) malloc(sizeof(clovek)*poc))

- tzn můžeš šahat p[0] až p[poc-1]

Ale dál v kódu přistupuješ i do p[poc]a p[poc+1], namátkově :

// ve funkci pridaj() :  

  while(i<=poc){
    if(p[i].exist==0                           

// ve funkci utried_m() :

         do{
         j=i;
         if(p[j].exist==1 && p[j+1].exist==1){
                             ...
                          }
         i++;
         }while(i<=poc);
         return;

// ve funkci poriadok() :

       do{
        if(p[i].exist==0 && p[i+1].exist==1){
                         p[i]=p[i+1];
                         p[i+1].exist=0;
                         presun==1;
                         }
        else presun=0;
        i++;
        }while(i<=poc);

Zdrojové kódy standardní knihovny najdeš třeba tady :

http://www.gnu.org/software/libc/

Ahoj, nevím jestli to pomůže, zkus mrknout na sourceforge:

http://sourceforge.net/directory/os:windows/?q=reservation%20system

Ahoj,

Ano po minimalizaci a maximalizaci je to smazáno protože se nezavolá ten kód co to vykreslil.
Většinou je zbytečné duplikovat kreslící kód na víc míst, je v tom pak jen bordel.
Běžně se všechno vykresluje ve WM_PAINT.
Naprogramuj WM_PAINT tak, aby vykreslovala současný stav okna/aplikace.
No a když se někde ten stav změní (třeba se změní nějaký text), je třeba oknu jen oznámit aby se překreslilo, tzn. po změně zavoláš:

// Označení pravoúhelníku, který se změnil a je třeba ho překreslit (NULL - celé okno)
InvalidateRect( hwnd, NULL, TRUE);
UpdateWindow(hwnd); // Ihned zavolá WM_PAINT která překreslí neplatný pravoúhelník
                    // (ten který je v předchozím řádku označen InvalidateRect - může jich být víc)

Toť vše, samotné vykreslení ať zařídí WM_PAINT.

Protože WM_PAINT je automaticky voláno při potřebě překreslení obrazu
v důsledků manipulací s oknem systémem např. změnách velikosti okna, např maximalizace.

A ty stejné řádky nemusí následovat po sobě? Pokud ti nezáleží na výstupním pořadí těch řádků, dá se to nejdřív seřadit v příkazovém řádku:

sort < soubor.txt /O temp.txt

a pak temp.txt v programu načítat řádek po řádku a když je následující řádek řádek jiný než předchozí, první, neprázdný, zapsat ho do výstupního souboru, zbytek zahodit. Chceš-li zachovat původní pořadí řádků bude to trochu složitější.

Já zas když byl na pohovoru, tak jen chtěli přinést ukázku nějakého

mnou psaného kódu. Pán se na něj zběžně podíval a zajímala ho především

štábní kultura. Jestli nemám moc dlouhý funkce, nelíbilo se že nemám moc komentáře.

Čekal jsem spíš, že ho bude zajímat podrobněji co to dělá a jak.

Je to hrozně individuální, záleží na koho narazíš.

Ahoj, není to zrovna s cyklem WHILE a nevím jestli tam nemám

syntaktickou chybu (Ve VB taky nedělám), ale mělo by to fungovat.

Vyzkoušej to, snad ti to pomůže.

(Na přesné hodnotě toho čísla 1000000000000 nezáleží,

mělo by být ale větší než největší číslo jaké v tom sloupci bude)

Option Explicit

Sub hladaj()

    Dim riadky As Integer
    Dim i As Integer
    Dim priemer As Double
    Dim hladane As Double
    Dim oznacenie As String
    Dim nalezeno As Integer
    Dim nejblizsiVyssi As Double
    Dim nejblizsiVyssiIndex As Integer
    
    riadky = Range("A1:A8").Rows.Count
    priemer = Range("E2").Value
    nalezeno = 0

    For i = 1 To riadky
        If Cells(i, 1) = priemer Then
            hladane = priemer
            Range("F2").Value = hladane
            oznacenie = Cells(i, 2)
            Range("G2") = oznacenie
            nalezeno = 1
        End If
    Next i
    
    If nalezeno = 0 Then
      nejblizsiVyssi = 1000000000000
      nejblizsiVyssiIndex = 0
      For i = 1 To riadky      
        If Cells(i, 1) > priemer Then
          If Cells(i, 1) < nejblizsiVyssi Then
            nejblizsiVyssi = Cells(i, 1)
            nejblizsiVyssiIndex = i
          End If  
        End If
      Next i
      Range("F2").Value = nejblizsiVyssi
      oznacenie = Cells(nejblizsiVyssiIndex, 2)
      Range("G2") = oznacenie
    End If

End Sub

Taky možnost:

#include <stdio.h>
#include <limits.h>

#define MAX(a, b) (((a) >= (b)) ? (a): (b))
#define MIN(a, b) (((a) <= (b)) ? (a): (b))

int main()
{
  int cislo, max = INT_MIN, min = INT_MAX;
  
  while (scanf("%d", &cislo) && cislo != 0) {
    max = MAX(max, cislo);
    min = MIN(min, cislo);
  }  
  
  printf("%d--%d", min, max);

  return 0;
}

#3 ico222
To už bys měl zvládnout sám.

struct NODE {
  int   number;
  NODE* next;
};

struct FIFO {
  NODE* first;
  NODE* last;
};

void init(FIFO* fifo)
{
  fifo->first = NULL;
  fifo->last  = NULL;
}

void push(FIFO* fifo, int number)
{
  NODE* node = new NODE;
  node->number = number;
  node->next   = NULL;

  if (fifo->last) {
    fifo->last->next = node;
  } else {
    fifo->first = node;
    fifo->last  = node;
  }
}

int pop(FIFO* fifo)
{
  assert(fifo->first != NULL && "Fronta je prazdna!");
  
  NODE* node = fifo->first;
  int number = node->number;
  
  fifo->first = node->next;
  delete node;

  if (fifo->first == NULL) fifo->last = NULL;

  return number;
}

Tady jsem zbastlil kód který ti třeba pomůže, ale rychlost nic moc :-)

(Princip je asi takový, že se postupně k součtu rekurzivně přičítají všechny kombinace prvků rozkladu)

#include <stdio.h>
#include <assert.h>
#include <string.h>

#define DELKA_ROZKLADU (sizeof(prvociselnyRozklad) / sizeof(prvociselnyRozklad[0]))

int prvociselnyRozklad[] = {2, 2, 5}; // Cisla v rozkladu musi byt serazena vzestupne

struct BLOCK {  
  int* mocniny;
  int  powCount;
};

BLOCK blocks[DELKA_ROZKLADU];
int   blocksCount = 0;

void InitBlocks();
void PrintBlocks();
int RecursiveSum(int start, int mul); // Pozor: hloubka rekurze = pocet mocnin v rozkladu + 1 (např pro 2^4 * 5 je hloubka = 3)

int main(int argc, char* argv[])
{  
  int slozeneCislo = 1;
  for (int j = 0; j < DELKA_ROZKLADU; j++) {
    slozeneCislo *= prvociselnyRozklad[j];
  }

  InitBlocks(); // Prevede jednotlive prvky v rozkladu na mocniny (napr 2, 2, 2, 3, 3, 5 na 2^3, 3^2, 5)
  PrintBlocks();

  int sum = 1 + RecursiveSum(0, 1) - slozeneCislo;

  printf("Soucet delitelu: %d\n", sum);
	return 0;
}

void InitBlocks()
{
  blocksCount = 0;
  blocks[blocksCount].powCount = 1;
  blocks[blocksCount].mocniny = prvociselnyRozklad;
  int j = 1;
  while (j < DELKA_ROZKLADU) {
    if (prvociselnyRozklad[j] != blocks[blocksCount].mocniny[0]) {
      blocksCount++;
      blocks[blocksCount].powCount = 1;  
      blocks[blocksCount].mocniny = prvociselnyRozklad + j;
    } else {
      prvociselnyRozklad[j] *= prvociselnyRozklad[j - 1];
      blocks[blocksCount].powCount++;  
    }   
    j++;
  }
  blocksCount++;
}

void PrintBlocks()
{
  for (int j = 0; j < blocksCount; j++) {
    if (blocks[j].powCount == 1) {
      printf("%d", blocks[j].mocniny[0]);
    } else {
      printf("%d^%d", blocks[j].mocniny[0], blocks[j].powCount);
    }
    if (j < blocksCount - 1) {
      printf(" * ");
    }
  }
  printf("\n");
}

int RecursiveSum(int start, int mul) 
{
  int sum = 0;
  for (int blockIndex = start; blockIndex < blocksCount; blockIndex++) {
    for (int powIndex = 0; powIndex < blocks[blockIndex].powCount; powIndex++) {
      const int m = mul * blocks[blockIndex].mocniny[powIndex];
      sum += m + RecursiveSum(blockIndex + 1, m);
    }
  }  
  return sum;
}

#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <string>

using namespace std;

int  ZjistiCisloRadku(const string& line);
void PrevedStrednikyNaTabulatory(string& line);

int main ()
{
  int vypsatRadek = 2;
  
  cout << "Kod\tNazev\t\tCena za kus\n";
  ifstream inFile ("vyrobky.csv");

  string line;  
  while (getline (inFile, line)) {
    int cisloRadku = ZjistiCisloRadku(line);
    if (cisloRadku == vypsatRadek) {
      PrevedStrednikyNaTabulatory(line);
      cout << line << '\n';
      break;
    }
  }

  return 0;
}

int ZjistiCisloRadku(const string& line)
{
  int delkaCisla = line.find(';');  
  string retezecSCislem = line.substr(0, delkaCisla);  
  return atoi(retezecSCislem.c_str());  
}

void PrevedStrednikyNaTabulatory(string& line)
{  
  for (int i = 0; i < line.length(); i++) {
    if (line[i] == ';') line[i] = '\t';
  }      
}

Pardon, to opakované volání QueryPerformanceCounter v cyklu je zbytečné

(samotná režie cyklu má tady v podstatě nulovej vliv)

lepší takto:

  QueryPerformanceCounter(&a.li);     
  for (i = 0; i < SAMPLES; i++) {
    MerenaRutina();
  }
  QueryPerformanceCounter(&b.li);
  sum = b.i64 - a.i64;

Tady máš ukázkový kód. Jak připojit knihovnu kernel32.lib nemusíš ve většině

Vývojových prostředí (IDE) řešit, bývá připojena automaticky

Ukázkový kód chodí ve Visual Studiu i DevC++

#include <windows.h>
#include <stdio.h>

// Pocet vzorku, kolikrat se ma merit
#define SAMPLES 1000

// Definice 64-bitoveho integeru (starší verze Visual Studia nemají typ long long)
#if defined(_MSC_VER)    
  typedef __int64 INT64;    
#else
  typedef long long INT64;
#endif

// Funkce QueryPerformance... pozaduji parametr typu LARGE_INTEGER,
// pro snazsi dalsi pocitani s vracenym 64bitovým integerem si definuju union
union COUNTER {
  LARGE_INTEGER li;
  INT64 i64;        
};

void MerenaRutina()
{
  printf("");
}

int main(int argc, char* argv[])
{
  COUNTER freq, a, b;
  INT64 empty, sum, average;
  int i;
  double s;

  // Zjisteni frekvence citace
  QueryPerformanceFrequency(&freq.li);

  // Zjisti jak dlouho trva samotne volani QueryPerformanceCounter
  QueryPerformanceCounter(&a.li);     
  QueryPerformanceCounter(&b.li);
  empty = b.i64 - a.i64;

  // Samotne mereni opakovane SAMPLES-krát
  sum = 0;
  for (i = 0; i < SAMPLES; i++) {
    QueryPerformanceCounter(&a.li);     
    MerenaRutina();
    QueryPerformanceCounter(&b.li);
    sum += b.i64 - a.i64;
  }

  // Jaký je prumerny cas
  average = sum / SAMPLES; 
  average -= empty;
  if (average < 0) average = 0;
   
  s = (double) average / (double) freq.i64;
  printf("\nJedno volani MerenaRutina() trva prumerne: %g mikrosekund\n", s * 1000000.0);
  getchar();
  
  return 0;
}

Ještě pro upřesnění dodám že rozlišení měření času a přesnost měření času
jsou dvě různé věci. S rozlišením není ani na PC problém.

S přesností je to horší, protože tvůj program neběží na počítači sám,
jsou tu stovky běžících programů, procesů, ale jenom jeden nebo pár procesorů.
Aby windows vytvořil zdání, že všechny tyhle úlohy běží současně, rychle mezi nimi
přepíná, tj. chvilku běží ta úloha, chvilku jiná. Problém je že ty nevíš kdy se to stane
a stane se to i třeba v okamžiku kdy zrovna měříš. Tvůj program je na chviličku pozastaven
(windows ti ukradne procesor :-) ) a běží jiný, za chvíli ti ho vrátí, ale o tu chvilku
kdy si ho neměl je přesnost tvého měření zprzněna a výsledná hodnota měření času zašuměna
nepravidelnými a nepředvídatelnými událostmi. I věci jako že uživatel hejbne s myší,
nebo systém zrovna přistupuje ke stránkovacímu souboru, dojde k nějaké události na portech,
přerušení od nějakého zařízení a já nevím co všechno se v systému děje.
Nedá se to předvídat. Ale s určitými omezeními lze dopady těchle věcí minimalizovat.
Můžeš v průběhu měření dočasně nastavit procesu vyšší prioritu (pokud je měření krátké, i tu nejvyšší prioritu), zvýšíš tím šanci
že ti windows procesor neukradne. Ale není to jistota. Zbylý šum se dá odfiltrovat
jak už tu psal yaqwsx tím že měření opakuješ vícekrát a zprůměruješ to (před zprůměrováním
je dobré odstranit ty největší hodnoty).
S takovými opatřeními se dá dosáhout i mikrosekundové přesnosti.

#1 Franceq
Na přesnější měření jsem vždycky používal WinAPI funkce:

QueryPerformanceCounter (Vrací hodnotu čítače s vysokým rozlišením)

QueryPerformanceFrequency (Vrací frekvenci čítače s jakou čítá nahoru)

Obě jsou v kernel32.lib

Ta frekvence je na PC tuším alespoň 1,18MHz, dnes často i přímo frekvence procesoru

tj. Rozlišení minimálně na mikrosekundy a lepší.

#2 lukas.balaz
Když obraz jen problikne, tak je to v pořádku.

Ta ukázka použití dělá jen to že asercí ověří že pro všechny čísla

ta odmocnina funguje dobře.

Na Zdroják jsem umístil algoritmus pro výpočet celočíselné druhé odmocniny užitím bitových posunů.

viz http://code.programujte.com/code/72:celociselna-odmocnina-s-pouzitim-bitovych-posunu

Dokáže někdo odvodit algoritmus pro N-tou odmocninu

a uvést postup jakým takový algoritmus odvodil.

Máte týden, potom prozradím jak jsem na to šel já.

Na zdroják jsem přidal kód, který řeší, jak udělat násobení bez operace násobení

jen s operací bitových posunů a přičítání viz

http://code.programujte.com/code/71:celociselne-nasobeni-jen-pomoci-pricitani-a-bitovych-posunu

Obecné dělení, nejen mocninou 2 lze udělat i rychleji než postupný odčítáním

přidal jsem kód do zdrojáků viz

http://code.programujte.com/code/70:celociselne-deleni-a-zbytek-jen-pomoci-scitani-a-bitovych-posunu

#1 Fugii
Ve windows to jde takto (ukázkový program vypisuje na stejné pozici číslo od nuly do 99):

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

void gotoxy(int x, int y) // x,y - souradnice od nuly (standardne 0..79, 0..24)
{
  HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  COORD coord = {x, y};
  SetConsoleCursorPosition(handle, coord);
}

int main(int argc, char* argv[])
{
  for (int i = 0; i < 100; i++) {
    gotoxy(39, 12);
    cout << i;
    cout.flush(); // cout << neco uklada pred vypsani do bufferu, tohle zajisti ze se to co je v bufferu hned vypise (buffer vyprazdní)
    Sleep(100);
  }
  cout << '\n';
  return 0;
}

Jinak pro ovládání konsole je ve WinAPI celá skupna funkcí viz

http://msdn.microsoft.com/en-us/library/ms682073%28v=vs.85%29.aspx

#3 rAdo
Jo, ale ber to jen jako takovej náčrtek,
jedna z možností, neříkám že nejlepší.
Taky dát pryč ty aserce, doplnit kontrolu chyb v souboru,
uvolnit alokovane misto atd.
Kdyby si to chtěl mít všechno v jednom poli,
taky by to tak šlo, uprava by nebyla ani nijak slozita

Ale s tím už si určitě pohraješ.

Hodně zdaru.

Tady máš na rychlo zbastlený kód v C, který načte textový soubor "data.txt" v tom Tvém formátu

body do pole bodů, čáry do pole čar, trojúhelníky do pole trojúhelníků, čtyřúhelníku do pole čtyřúhelníku

a na zkoušku ty věci vypíše do "test.txt"

Funguje to obecně, můžeš si to libovolně  vybagrovat a upravit jak potřebuješ

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>

const int VERTEX_MAX = 4; // Maximalni pocet vertexu v radku

// Preskoci mezery a tabulatory
void SkipWhite(FILE* file) 
{
  int c;
  do {
    c = getc(file);
  } while (c == ' ' || c == '\t');
  if (c != EOF) {
    ungetc(c, file);
  }
}

// Nacte jedno cislo
int ReadNumber(FILE* file) 
{
  int c;
  char buf[64];  
  int i = 0;
  while ((c = getc(file)) != EOF && c != '\n' && c != ' ' && c != '\t' && c != ',') {
    assert(i < 63);
    buf[i++] = (unsigned char) c;
  }
  buf[i] = '\0';
  if (c != EOF) {
    ungetc(c, file);
  }
  return atoi(buf);
} 

// Nacte cisla do konce radku oddelena bilymi znaky (mezera nebo tabulator) nebo carkou, vrati pocet cisel
int ReadNumbersToLineEnd(FILE* file, int* numbers, int maxCount) 
{
  int c;
  int count = 0;
  bool pokracovat = true;
  while (pokracovat) {
    SkipWhite(file); 
    assert(count < maxCount && "V radku je vic nez povoleny pocet cisel");
    numbers[count++] = ReadNumber(file);
    SkipWhite(file);
    c = getc(file);
    if (c == ',') {
      SkipWhite(file);
      c = getc(file);
    }
    if (c == EOF || c == '\n') {
      pokracovat = false;
    } else {
      ungetc(c, file);
    }
  } 
  return count;
}

// count[1] - pocet points
// data[1] - pole points
// count[2] - pocet lines
// data[2] - pole lines
// count[3] - pocet triangles
// data[3] - pole triangles
// count[4] - pocet quads
// data[4] - pole quads
// atd.
struct OBJECTS {
  int count[VERTEX_MAX+1];
  int* data[VERTEX_MAX+1];
}; 

bool ReadObjects(const char* fileName, OBJECTS& objects)
// Nacte objekty z textoveho souboru
{
  FILE* file = fopen(fileName, "r");
  if (!file) return false;
    
  for (int i = 0; i <= VERTEX_MAX; i++) objects.count[i] = 0;
    
  int numbers[VERTEX_MAX]; // Pro docasne ulozeni jednoho radku cisel

  int c;
  bool pokracovat = true;
  while (pokracovat) {
    SkipWhite(file);
    c = getc(file);
    if (c == 'v') {
      const int numCoord = ReadNumbersToLineEnd(file, numbers, sizeof(numbers) / sizeof(int));
      if (numCoord > 0) {
        int* data = objects.data[numCoord];
        if (data) {
          memcpy(&(data[numCoord * objects.count[numCoord]]), numbers, numCoord * sizeof(int));
        }
        objects.count[numCoord]++;
      }
    } else if (c == ';') { // Komentar
      while ((c = getc(file)) != '\n' && c != EOF) {} // Cist az do konce radku
    } else if (c == EOF) {
      pokracovat = false;
    } else if (c == '\n') {
      // Prazdny radek, nedelat nic
    } else {
      assert(!"Neplatny znak na zacatku radku");
    }
  }

  fclose(file);
  return true;
}

// Testovaci vypis objects
void TestPrint(OBJECTS& objects)
{
  FILE* file = fopen("test.txt", "w");
  assert(file);
  
  char* name[4+1] = {"", "point", "line", "triangle", "quad"};
   
  for (int obj = 1; obj <= 4; obj++) {
    fprintf(file, "%d %ss\n", objects.count[obj], name[obj]);
    for (int i = 0; i < objects.count[obj]; i++) {   
      fprintf(file, "  %s(", name[obj]);
      for (int j = 0; j < obj; j++) {      
        fprintf(file, "%d", objects.data[obj][obj*i+j]);
        if (j < obj-1) {
          putc(',', file);
          putc(' ', file);
        }
      }
      fprintf(file, ")\n");
    }
  }

  fclose(file);
}

int main(int argc, char* argv[])
{  
  OBJECTS objects;
  memset(&objects, 0, sizeof(objects));
  
  // Zjisti pocet jednotlivych objektu v souboru
  // Protoze objects.data[i] = NULL, nenacita data, jen spocita pocet objektu
  ReadObjects("data.txt", objects); 
  
  // Alokuje misto
  if (objects.count[1] > 0) objects.data[1] = new int[1 * objects.count[1]]; // Misto pro body
  if (objects.count[2] > 0) objects.data[2] = new int[2 * objects.count[2]]; // Misto pro cary
  if (objects.count[3] > 0) objects.data[3] = new int[3 * objects.count[3]]; // Misto pro trojuhelniky
  if (objects.count[4] > 0) objects.data[4] = new int[4 * objects.count[4]]; // Misto pro ctyruhelniky
  
  // Nacte objekty
  ReadObjects("data.txt", objects);

  // Na zkousku vypise objects do souboru test.txt
  TestPrint(objects);

  return 0;
}

Např pokud bude v souboru data.txt:

; bla bla bla - komentar
v 3

v 15 5 13 4
v 32 1 5 15
v 1 2

v 15 2 1
v 13 25 0 3
v 8, 5, 7

tak do test.txt vypíše:

1 points
  point(3)
1 lines
  line(1, 2)
2 triangles
  triangle(15, 2, 1)
  triangle(8, 5, 7)
3 quads
  quad(15, 5, 13, 4)
  quad(32, 1, 5, 15)
  quad(13, 25, 0, 3)

Kdyžtak se ptej.

#3 akero
Nemusíš, můžeš ho používat i jen tak, ani se nemusíš registrovat.

Stáhneš, nainstaluješ a můžeš tvořit.

Výsledný tišťák si vytiskneš. Má to i export do DXF

Já nevím třeba se ti nebude líbít, ale zkusit ho můžeš.

Na škole jsme taky dělali v programu Sprint Layout 2.0, teď už je verze 5.0

Dvojka byla velmi jednoduchá. Ale tenhle program je placenej.

Na pak každej kdo se tím zabývá vážněji ti doporučí Eagle

ale ten už je trochu složitější.

Určitě najdeš i další free programy.

#1 akero
Mě celkem vyhovoval program ExpressPCB, je jednoduchý, zdarma

Firma co ho vytvořila se zabývá výrobou tišťáků, vytvořených v tomto programu,

jako že si tišťák navrhneš a můžeš u nich rovnou objednat, ale můžeš ho používat i jen tak.

Mají taky jednoduchý program ExpressSCH na kreslení schémat.

viz jejich web

Můžeš zkusit třeba takovou jednoduchou hru hádání čísel.

Počítač si "myslí" číslo od 1 do 100 a na uživateli je aby ho uhodl.

Počítač vypíše:

Uhodni číslo od 1 do 100

Ty zadáš číslo

Pokud ses trefil, počítač vypíše že si zvítězil a program skončí.

Pokud ses netrefil, počítač ti vypíše jestli je to číslo větší nebo menší než to co si zadal

Zadáváš tak dlouho dokud se netrevíš.

Může ti nakonec i vypsat po kolika pokusech ses trefil.

KIIV:
Možná jsem to jen blbě napsal, myslel jsem jak se co zapisuje.
Matematika je jazyk, programovací jazyk je taky jazyk ale zároveň posloupnost příkazů prováděna krok za krokem,
Vyjadřovací schopnosti těchto jazyků jsou obdobné,
ale ten zápis se trošku liší. V matematice je ten vztah
okamžitý. Když budu mít napsaný na papíře nějaký výpočet,
tak všechny rovnice platí současně a nemůže být teda x=něco a zároveň x=něco_jiného
Nemůžu třeba do testu z matematiky ve škole zapsat:

x = 2
x = 3
y = x + 4

To bych dostal pětku protože 2 se nerovná 3
Ale v programu klidně můžu, vykonává se postupně krok za krokem

x = 2; // Od teď je x 2
.
.
.
x = 3; // Od teď je x 3
y = x + 4; // y bude 7

Na tenhle drobný rozdíl v zápisu jsem chtěl poukázat, snad jsem Mr.Bosse3D zbytečně nezmátl :-)

Jo samozřejmě pokud se na tu funkci y = x + 4 díváme dynamicky
tak měnící se x způsobuje měnící se y, proti tomu nic.

Chceš-li to říct ještě jinak:

Proměnná něco zastupuje. zastupuje číslo.
Když budeš mít v matematice zadáno

a = 5
b = a + 2

Tak je a = 5, b = 7 a to už napořád,
nemůžeš pak později třeba říct že a = 10, to by tady znamenalo že 5=10 což je nesmysl
Matematicky je taky výraz x = x + 1 nesmysl (0=1)
Takhle to je v matematice, to tě asi mate.

V programování je to ale trochu jinak,
proměnná má určitou hodnotu jen do doby než ji změníš:

int x;     // Definice typu proměnné x (viz dál)
x = 5;     // Nastav x na 5
cout << x; // Vypíše x (tedy 5)
x = 10;    // Nastav x na 10
cout << x; // vypíše x (teď už 10)
x = x + 2; // Nastav x na x + 2. Není to rovnice. Nejdřív se vždycky spočítá to napravo od rovnáse (x + 2) a výsledek se strčí do proměnné nalevo od rovná se.
           // Zatím je x = 10, k tomu se přičte 2,
           // výsledek je 12 a to bude nová hodnota x
           // Také se dá tento řádek přeložit slovy jako: Zvyš x o 2
cout << x; // Vypíše x (teď už teda 12)

Před prvním použitím proměnné se v jazyce C++ musí definovat co ta proměnná vlastně je zač, jakého je typu,
může to být např číslo, znak, text, atd. (Ve většině programovacích jazyků musíš všechny proměnné před prvním použitím definovat)

int x; // Tímhle řádkem říkáš že x je celé číslo v tom rozsahu přibližně od -2miliardy do 2miliard
       // V paměti pak proměnná x bude zabírat 4bajty, tohle je asi vůbec nejpoužívanější typ,
       // když potřebuješ celé číslo a nemáš žádné další požadavky na velikost, int je jasná volba.
       // Mužeš pak do x dát jakékoli celé číslo z rozsahu toho typu int, ale pokud by si rozsah překročil např. někde zadal x = 3000000000;
       // stane se nemilá věc a zapíše se do x něco jiného než si chtěl, protože se to prostě do těch 4bajtů nevejde.     
       // Představ si to tak že touhle definicí se kdesi v paměti vytvoří místečko pro x, a od tohoto řádku
       // bude překladač vědět že nějaké x existuje, má pro něj vyhrazené místo a když se pak někde objeví x = neco;
       // bude vedet na jaké místo v paměti to neco má šoupnout.

Definice proměnné se dá spojit rovnou s prvním nastavením její hodnoty (inicializací), tzn. můžeš použít

int x = 5;

to je zkráceně to samé jako:

int x;
x = 5;