Dynamické jednorozměrné pole – C / C++ – Fórum – Programujte.com

Čau, mám char buffer[25]. Chtěl bych, asi program sám udělal buffer velký jak potrebuje.
 Jak na to?

char *buffer = new char[pocetprvku];
...
delete buffer;

char *buffer = malloc(pocetprvku * sizeof(char));
...
free(buffer);

#2 z
delete [] buffer;

#3 KIIV
njn :-)

V 

int volne_pole_cislo(int cislo, int radek, int sloupec) /*Funkce testuje, jestli cislo uz je v poli, radku, 3x3 nebo diagonale*/
{
    char buffer[25];
	
	int i, j, k, l, m, n, a , b;


    	for (i = 0; i < 8; i++) {
             a = 0;
    	     a +=  i;
            if (sudoku[i][a] == 0 ) continue;
		for (j = i + 1; j < 9; j++) {
		    b = 0;
            b += j;
			if (sudoku[j][b] == sudoku[i][a]) return (0);
        }
    }

        for (i = 0; i < 8; i++) {
            k = 8;
            m = 0;
            m = k - i;
            if ( sudoku[i][m] == 0 ) continue;
        for (j = i + 1; j < 9; j++) {
            n = 8;
            l = 0;
            l = n - j;
            if (sudoku[j][l] == sudoku[i][m]) return (0);
        }
    }

	for (i = 0; i < 9; i++) if (sudoku[radek][i] == cislo)   return(0);
	for (i = 0; i < 9; i++) if (sudoku[i][sloupec] == cislo) return(0);


	transformuj_ctverecek_poli(buffer, radek, sloupec);
	for (i = 0; i < 9; i++) if (buffer[i] == cislo) return (0);
	/* Jestli se mozne dane cislo doplnit podle splnenych podminek vrati funkce TRUE*/
	return(1);
}/*konec volne_pole_cislo*/

void transformuj_ctverecek_poli(char buffer[], int radek, int sloupec) /*Transformuje 3x3 ctverec do 1-dimenzionalniho pole*/
{
	int i, j, k;

	while ((radek % 3) != 0) radek--;
	while ((sloupec % 3) != 0) sloupec--;
	k = 0;
	for (j = radek; j < radek + 3; j++) {
		for (i = sloupec; i < sloupec + 3; i++) {
			buffer[++k] = sudoku[j][i];
		}/*konec for i*/
	}/*konec for j*/
}/*konec transformuj_ctverecek_poli*/

No vypadá to takhle...

bez toho ani by pocetprvku bylo napred zadáno by to asi nešlo že?

alokovat dynamicky pole nějaké velikosti, evidovat si ve dvou proměnných alokovanou velikost a využitou velikost, hlídat aby nedošlo k přetečení pole a realokovat pokud jeho alokovaná velikost nestačí. Jednodušeji to jde udělat tak, že použiješ něco hotového, třeba vector

hu

no a jeste mam globalne char sudoku[9][9]; Chtěl bych, aby to vypadalo nejak takhle   

int zadej_zadani(void) /* Funkce pozada o zadani na kazdem radku 9 cisel */
{
	int radek; char **sudoku;

	printf("Zadejte prosim zadani: \n");

	while (1){
		for (radek = 0; radek < 9; radek++){
			if (! zadej_radek(radek, sudoku)) return (0);
		}/*konec for*/
		printf("\n Problem sudoku: \n");
		zobraz_sudoku();
		if (zkontroluj_vstupni_zadani()) return(1);
		else printf("\n");
	}/*konec while*/
}/*konec zadej_zadani*/

int zadej_radek(int radek, char **sudoku) /*Do pole se zadavaji cisla od 0 do 9, nezalezi jestli jsou oddelena od sebe nebo ne. /
                           /*Pouze prvnich 9 cisel bude nacteno*/
                           /*Pouzil jsem fgets() s gets() to nemusi fungovat*/
 {

	int c, i;
	int sloupec = 0;
	int vysledek = 1;

	/*Nulovani pole*/
	for (i = 0; i < 9; i++) {
		sudoku[radek][i] = 0;
	}/*konec for*/
	printf("radek %d : ", radek + 1);
	while(1){
		c = getc(stdin);
		if (c == feof(stdin) || c == 0x0A) return vysledek;
		else if ((c == 'Q') || (c == 'q')) vysledek = 0;
		/*Prevede zadani do radku sudoku*/
		else if ((vysledek) && (sloupec < 9) && (c >= '0') && (c <= '9')) {
            sudoku[radek][sloupec++] = c - 48;
		}/*konec if*/
	}/* konec while*/
}/*konec zadej_radek*/

Abych měl ukazatel ve funkci. A v main() char sudoku[9][9]. Nevím přesně jak se to dělá. Jde i o globální deklarace odstranit lépe?

nevim jestli ti to nějak pomůže, ale:

1) sudoku je matice, takže můžeš použít normální pole a né dvojrozměrný char**, protože tam stejně budeš mít jen čísla 0-9 a velikost je vždy 9

unsigned* matice = (unsigned *)calloc(9 * 9, sizeof(unsigned));

2) jako globální můžeš nastavit velikost matice, protože je vždy 9 

#define SIZE 9

3) kdyb to bylo C++, tak můžeš použít třídy, ale v C dej hlavní pole matice do main() a jako parametr budeš vždy předávat jen ukazatel na pole, protože velikost znáš 

void generujMatici(unsigned* matice, unsigned obtiznost)
{
    // ...
}

int main()
{
    unsigned* matice = 0; // alokace (bod 1.)
    
    // neni nutne potom vynulovat matici, protoze calloc ji vynuluje pri alokaci.. takze muzes jen generovat a pracovat s tim
    generujMatici(matice, 1); // obtiznost treba 1-5

    return 0;
}

Další funkce, který budeš používat už máš nebo si uděláš, ale vždy bude stačit a bude i nutnost dávat jako parametr unsigned*

Program funguje tak, že zadáš hodnoty do pole sudoku a on ti zkontroluje, jestli si nezadal spatne zadani. A pak podle nejakych funkci to resi. Jestli neni zbytecne pridelovat tady dynamicke pole.  Jedině, kde bych to potřeboval je buffer[] něco jako pamět pro čísla. Ulozi si jich tam tolik kolik potrebuje podle obtiznosti sudoku X. 

Mam to rozdeleny na 3 casti : v jedne mam funkci prototypy, v jednom main a v poslednim funkce. Pole vyuzivam ve vice funkci. Takže by to mělo jít takhle? Nemám moc velký zkušenosti v programování.

a hlavně, nevím jestli to půjde, když mám funkci s rekurzívou

Zkusil jsem to na rychlo udělat a nějak takto by to mohlo být.. pokud teda jde čistě o kontrolu hotového sudoku

sudoku.h 

#pragma once
#include <iostream>

#define SUDOKU_SIZE 9

typedef unsigned char ubyte;

bool isValidSudoku(const ubyte* sudoku);

sudoku.cpp 

#include "sudoku.h"

static bool existsInBuffer(const ubyte* buffer, const ubyte value, const int bufferSize)
{
    for (int i = 0; i < bufferSize; ++i)
    {
        if (*(buffer + i) == value)
            return true;
    }
    return false;
}

static bool areValidRow(const ubyte* sudoku, const int rowIndex)
{
    ubyte buffer[SUDOKU_SIZE] = { 0 };

    for (int i = 0; i < SUDOKU_SIZE; ++i)
    {
        ubyte value = *(sudoku + rowIndex + i * sizeof(ubyte));

        if (!existsInBuffer(buffer, value, i))
        {
            *(buffer + i) = value;
        }
        else return false;
    }
}

bool isValidSudoku(const ubyte* sudoku)
{
    ubyte buffer[SUDOKU_SIZE];
    bool state = false;

    for (int n = 0; n < SUDOKU_SIZE; ++n)
    {
        if (!areValidRow(sudoku, SUDOKU_SIZE * n))
            return false;
    }
    return true;
}

main.cpp 

#include "sudoku.h"
#include <iostream>

int main()
{
    ubyte sudoku[] = {
        1,2,3,4,5,6,7,8,9,
        2,3,4,5,6,7,8,9,1,
        3,4,5,6,7,8,9,1,2,
        4,5,6,7,8,9,1,2,3,
        5,6,7,8,9,1,2,3,4,
        6,7,8,9,1,2,3,4,5,
        7,8,9,1,2,3,4,5,6,
        8,9,1,2,3,4,5,6,7,
        9,1,2,3,4,5,6,7,8
    };

    std::cout << (isValidSudoku(sudoku) ? "Sudoku je v poradku!" : "Sudoku neni spravne!");
    std::cin.get();

    return EXIT_SUCCESS;
}

Mohl bych se s nekym zkusenejsim zkontaktovat? Program je hotovy a funguje. Na zapocet jsou tam nejake vyhrady.

Zasláno z mobilního telefonu.