Asi neplatný prístup do pamäti – C / C++ – Fórum – Programujte.com

void s(){
    char** SPZ; 
    SPZ = n(); int i;
    for (i = 0; i < 5; i++){ //kontrola
        printf("%s\n", SPZ[i]);
    }
    for (i = 0; i < 5; i++){
        while (**SPZ != '\0'){
            putchar(**SPZ++);
        }
        putchar('\n');
        *SPZ++;
    }
}

vlastne do SPZ si volam funkciu n ktora mi dynamicky alokuje pole SPZtiek.

toto je kontrolny vypis aby ste videli čo obsahuje moje pole SPZ..

Připojen obrázek.

a chcel by som to pole, teda kazdu jednu SPZku vypisovat po jednom znaku, vlastne vypis bude taky isty len ja to chcem po jednom znaku, lebo potom neskor by som chcel tam vlozit medzery aby to vyzeralo takto nejak "BA 353 AB"

ale hadze mi 

Unhandled exception at 0x012047AE in PRPR PROJEKT 1.exe: 0xC0000005: Access violation reading location 0xCDCDCDCD. niekto nejaky hint? :) dakujem

doporucil bych nedelat saskarny jako  *SPZ++ ... muzes tam klidne mit problemy s prioritou a hlavne to meni to pole ukazatelu... takze podruhy uz ti to neda stejny vysledky...

Proc nepouzijes  const char *x = SPZ[i]; a to pak nevypises tim cyklem? To x uz v klidu menit muzes...

#2 KIIV
 

const char *x = SPZ[0];
	/*for (i = 0; i < 5; i++){ //kontrola
		printf("%s\n", SPZ[i]);
	}*/
	
	while (x != '\0'){
		putchar(x++);
	}

takto si viem, vypisat po jednom znaku akurat prvu SPZku, ale ako dalšie SPZky..

#3 vrtkoo
spz by mala mat fixnu velkost, mozes spravyt nieco taketo:

enum{ SPZ_SIZE = 7 };

typedef char SPZ[SPZ_SIZE+1];

void printSPZ(SPZ* spz){
    assert(spz);
    assert(SPZ_SIZE >= 7);
    printf("%.2s %.3s %.2s\n", (*spz), (*spz)+2, (*spz)+5);
}

void testSPZ(){
    SPZ spzs[] = {
        "BA123AB",
        "BA353AB",
        "DS353AB",
    };

    for(int i=0; i < 3; ++i){
        printSPZ(spzs+i);
    }
}

#3 vrtkoo
 

	// brain, use your brain, luke
	for (i = 0; i < 5; i++) {
		const char *x = SPZ[i];
		while (x != '\0'){
			putchar(x++);
		}
	}

#5 KIIV
presne to mam, zacykly sa to fajne..  

for (i = 0; i < 5; i++) {
		const char *x = SPZ[i];
		x = 0; //ešte toto treba ale nejak to nejde..
		while (x != '\0'){
			putchar(x++);
		}
	}

no ak tam dam to x = 0; tak uz sa to nezacykly, akurat nič nevypiše. idem dalej skušať.

proc sakra  x=0;  to je to samy jako tam dat NULL .. udelat z toho null pointer a pak se to prekvapive zriti, protoze zkousis ziskat znak na adrese 0

#7 KIIV
hej som sa pomylil.. moja chyba, ale zacykluje sa to .. :( 

for (i = 0; i < 5; i++) {
		const char *x = SPZ[i];
		while (x != '\0'){
			putchar(x++);
		}
	}

nevidim nic, co by mohlo zpusobit zacykleni... jedina moznost je blbe to pole retezcu.. mozna bude jednodussi, kdyz to sem hodis cely a kdokoliv tady to bude mit opraveny za zlomek casu nez se tu s tim furt naslepo patlat

Já nějak nevidim důvod to procházet po znacích, když to později chceš jen kvůli tomu, aby si přidal mezery... ten formát má pevně danný rozmezí (2 písmena, 3 čísla, 2 písmena) = 7 znaků pro každý SPZ

trochu jsem to rozšířil pro generování spz a volitelných formátem, takže si všimni pouze fce injectSpaces(...)

není potřeba procházet po znacích, když víš, kde přesně má být mezera, potom jen poskládáš nový SPZ s mezerama

#define _CRT_SECURE_NO_WARNINGS

#define SPZ_PREFIX_LENGTH 2 // pocet znaku v prefixu
#define SPZ_SUFFIX_LENGTH 2 // pocet znaku v suffixu
#define SPZ_NUMBER_LENGTH 3 // delka cisla
#define SPZ_LENGTH (SPZ_PREFIX_LENGTH + SPZ_SUFFIX_LENGTH + SPZ_NUMBER_LENGTH)

#include <iostream>

using namespace std;

// nahodne pismeno mezi A-Z
char randomUpperCaseLetter()
{
    return rand() % ('Z' - 'A') + 'A' + 1;
}

// nahodne cislo jako char
char randomNumberAsChar()
{
    return rand() % 9 + '0';
}

// pro generaci SPZ (prvni N znaku)
char* randomSpzPrefix()
{
    char prefix[SPZ_PREFIX_LENGTH + 1];
    for (int i = 0; i < SPZ_PREFIX_LENGTH; i++) {
        *(prefix + i) = randomUpperCaseLetter();
    }
    *(prefix + SPZ_PREFIX_LENGTH) = '\0';
    return prefix;
}

// pro generaci SPZ (poslednich N znaku)
char* randomSpzSuffix()
{
    char suffix[SPZ_SUFFIX_LENGTH + 1];
    for (int i = 0; i < SPZ_SUFFIX_LENGTH; i++) {
        *(suffix + i) = randomUpperCaseLetter();
    }
    *(suffix + SPZ_SUFFIX_LENGTH) = '\0';
    return suffix;
}

// pro generaci SPZ (cislo v SPZ)
char* randomSpzNumber()
{
    char num[SPZ_NUMBER_LENGTH + 1];
    for (int i = 0; i < SPZ_NUMBER_LENGTH; i++) {
        *(num + i) = randomNumberAsChar();
    }
    *(num + SPZ_NUMBER_LENGTH) = '\0';
    return num;
}

// generuje SPZ
char** generateSpz(int count)
{
    char** spzs = new char*[count];
    for (int i = 0; i < count; i++) {
        char* spz = new char[SPZ_LENGTH + 1];
        strcpy(spz, randomSpzPrefix());
        strcat(spz, randomSpzNumber());
        strcat(spz, randomSpzSuffix());
        *(spz + SPZ_LENGTH) = '\0';
        *(spzs + i) = spz;
    }
    return spzs;
}

// vypise pole slov
void printCharArray(char** arr, int count)
{
    for (int i = 0; i < count; i++) {
        cout << *(arr + i) << endl;
    }
}

// vetkne mezeru mezi prefix/cislo/suffix
void injectSpaces(char** spzs, int count)
{
    for (int i = 0; i < count; i++) {
        char* newSpz = new char[SPZ_LENGTH + 3];
        int pos = 0;

        memcpy(newSpz + pos, *(spzs + i), SPZ_PREFIX_LENGTH);
        pos += SPZ_PREFIX_LENGTH;
        *(newSpz + pos++) = ' ';
        memcpy(newSpz + pos, *(spzs + i) + SPZ_PREFIX_LENGTH, SPZ_NUMBER_LENGTH);
        pos += SPZ_NUMBER_LENGTH;
        *(newSpz + pos++) = ' ';
        memcpy(newSpz + pos, *(spzs + i) + SPZ_PREFIX_LENGTH + SPZ_NUMBER_LENGTH, SPZ_SUFFIX_LENGTH);
        pos += SPZ_SUFFIX_LENGTH;
        *(newSpz + pos) = '\0';

        delete *(spzs + i);
        *(spzs + i) = newSpz;
    }
}

// odebere vsechny SPZ
void deleteSpzs(char** spzs, int count)
{
    for (int i = 0; i < count; i++) {
        delete *(spzs + i);
    }
    delete[] spzs;
}

int main()
{
    // v tvem pripade asi ze souboru nebo jako staticky...
    const int count = 8;
    char** spzs = generateSpz(count);

    printCharArray(spzs, count);
    injectSpaces(spzs, count); // pridani mezer do SPZ
    cout << endl;
    printCharArray(spzs, count);
    deleteSpzs(spzs, count); // uvolneni SPZ

    return EXIT_SUCCESS;
}

Výstup je potom jako (pro 8 SPZ)

RS748ZE
JN282HD
MR783MR
FD047WR
TV202OU
NS173EM
XJ623ME
TX516NK

RS 748 ZE
JN 282 HD
MR 783 MR
FD 047 WR
TV 202 OU
NS 173 EM
XJ 623 ME
TX 516 NK

#11 ingiraxo
stači mi to vypisať s tymi medzerami takze nevidim dovod si to komplikovať ale dakujem :)

#11 ingiraxo
a vedel by si mi poradiť ako vypisem ktorý okres/okresy sa opakuju najviac krat..

napr mam "BA123AB",

                 "BA353AB",

                 "DS353AB"

a ma mi vypisať 

BA 2

napadlo ma dačo take primitivne, ze si vypisem prve dva znaky z SPZky, vlozim si ich do nejakej premmenej respektive pola, ale čo dalej. dakujem

#13 vrtkoo
do mého řešení bych doimplementoval 

struct SpzComparer
{
    bool operator() (char const* a, char const* b)
    {
        return strcmp(a, b) < 0;
    }
};

struct MaxByValue
{
    template <typename A, typename B>
    bool operator() (const A& a, const B& b) const
    {
        return a.second < b.second;
    }
};

// vraci prefix a pocet vyskytu
char* getMostCommonPrefix(int& total, char** spzs, int count)
{
    map<char*, int, SpzComparer> map;
    char* maxPrefix = NULL;

    for (int i = 0; i < count; i++) {
        char* prefix = new char[SPZ_PREFIX_LENGTH + 1];
        memcpy(prefix, *(spzs + i), SPZ_PREFIX_LENGTH);
        *(prefix + SPZ_PREFIX_LENGTH) = '\0';
        map[prefix]++;
    }
    auto it = max_element(map.begin(), map.end(), MaxByValue());
    total = it->second;
    char* prefix = it->first;
    map.clear();
    return prefix;
}

v main() potom upravil na 

int main()
{
    srand(time(NULL));

    const int count = 1000;

    // puvodni kod...

    // nejcetnejsi prefix SPZ a jeho pocet
    int total;
    char* prefix = getMostCommonPrefix(total, spzs, count);
    cout << prefix << " = " << total << "x";

    // puvodni kod...
}

Samozrejmě je třeba přidat include 

#include <map>
#include <algorithm>
#include <time.h>

Tohle řešení ofc bude fungovat i na tvoji implementaci, stačí tomu předat pole spz a jejich počet

#13 vrtkoo
jde to ofc použít i bez mapy (kolekcí), ale v tomhle případě neznáš počet výskytů, takže by si musel celkem často realokovat...

musel bys vytvořit vlastní objekt, kde bude char* a int a to ulozit do pole 

// uchovas prefix SPZ a jeho cetnost
struct Item
{
public:
    char* prefix;
    int count;
};

// bude obsahovat pouze SPZ, ktery maji unikatni prefix.. tzn.
// pokud prefix "AB" nebude existovat, tak musis realokovat pole a zvednou
// ho o 1 a pridat novej prefix... v opacnym pripade vytahnes z pole Item s
// tím prefixem a zvednes mu jeho cetnost o 1
Item* items = new Item[1];

// nebo to udělat staticky s tím, že velikost pole bude stejná jako počet SPZ
// pripadne tez dynamicky, ale je tu uz placani pameti, pac vysledku bude rozhodne mene nez pocet SPZ
Item items[POCET_SPZ];

proto bych radsi pouzil kolekci, kde realokaci nemusis resit :)

prefix s největší četností potom získáš tak, že bud projdeš celý pole všech Itemů, nebo lépe..  ho seřadíš podle četnosti a vytáhneš 0 Item