Your program has an indeterminate behaviour, as there is an attempt to use beyond the memory of the masses.In this proposalint *tree = new int[n + 1]; memory n + 1 facilities intHowever, it is already in this cycle.for(int i = 1; i <= posA + n + 3 + 1 - 1; i++) tree[i] = 0; Reference is made to elements that are clearly more than n in termsi <= posA + n + 3 + 1 - 1 which is easier to writei <= posA + n + 3 In addition, within the function, the variable value n and the memory of the mass is not redistributed.if(n % 2 != 0) n++, tree[posA + n - 1] = 0; ^^^^ if((n / 2) % 2 != 0) n += 2, tree[posA + n - 1] = 0, tree[posA + n - 2] = 0; ^^^^^^ Pay attention to the code writing style. It's hard to understand what your program is doing.Try to declare functions in such a way as to perform one act. For example, in functions preparationToCreateTree input n should be transferred to another function or core code main♪ As a result, the function may be simplified and not usedint preparationToCreateTree( int n ) { int posA = 1; while( posA &lt; n ) posA *= 2; return posA; } In addition, questions arise as to whether or not correctly identified posA♪ Should its final value be less or equal nor it's nearest to the top.

Question solved, thank the user. https://ru.stackoverflow.com/users/190021/smithson ** This is an index. I mean, what's at the tmp address is also treated as an address and is already looking for a meaning.

The memory is right. Just for processing, you use it. lines issued Long a When the fprintf(%s) is removed to the file, a line is needed ASCII-z♪ Because you have line issued Long (max) - it won't be equal ASCII-z (programme out) Right ASCII-z in terms of this concept is your value plus a piece of debris from memory to zero. Then if you want to use the fprintf, then you're going to have to do the cycle and you're going to leave it on symbol (2) or add +1 bytes to memory, you don't give it to me in correction, you fill it with zero that it would be ASCII-z, and you'll be happy.As the best example[1], fprintf(myfile, "%s, text) should be replaced byfor(k=0;k<max;k++) fprintf(myfile, "%c", text[k]); or better.fwrite(text,1,max,myfile);

File has to open in two-way mode.fopen("input.txt", "rb")) Otherwise, it would be inaccurate to consider translations of lines.The length of the file to calculate by-the-side reading is, uh... That's a little weird. First, there's a couple. http://www.opennet.ru/man.shtml?topic=ftell&category=3&russian=0 ♪ Second - http://www.opennet.ru/man.shtml?topic=stat&category=3&russian=5 Option 1:FILE * f = fopen("input.txt", "rb"); fseek(f, 0L, SEEK_END); /* в filesize будет длина файла */ long filesize = ftell(f); /* переставили указатель в начало */ fseek(f, 0L, SEEK_SET); /* * выделяем память, читаем. */ fclose(f); Option 2:struct stat statbuf; stat( "input.txt", &statbuf ); /* теперь в statbuf.st_size содержится размер файла */ All right, there's got to be checks everywhere. And I haven't touched the other inconsistencies in the code yet (e.g., there's no point in expressing. size*sizeof(char)because sizeof(char) always 1; why sizeof(char) and sizeof(text) - I don't understand. Well, putting a buffer on the size of his fast reading file isn't the right thing.

Well, it's been easier than that:The initialization was indeed successful.after which the memory was given to the first elementThis first element came from the data structureAnd that line from the structure came with an address of 0x0. The data structure function is not written by me, so I didn't immediately suspect the exact location of the error. Forgive all those I didn't believe. Thank you, everyone.

In your program, you really read only one structure. ♪ http://linux.die.net/man/3/fread It says the functionsize_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream );reading nmemb (in your case of entities) struct gItemeach length size Byte.(And your program says fread(buffer,1,dbSize,db);, i.e. request dbSize 1-by-side records, which corresponds exactly to the size of one struct gItem♪Really. fread reading size * nmemb Byte, but he returns the number of records he reads. full)If you write: fread(buffer, itemSize, dbSize, db)You'll read all your own dbSize structures.

Definition lista It says lista.s It's a set of indexes, and you're in. dopisz I'm telling you what you're doing. slowo and the index received shall be assigned lista.s♪ I mean, your first mistake is that you're a simple index to assign to the index.The second problem is, you have a memory leak in your line. L->s[L->n] = (slowo*)malloc(sizeof(slowo));//ошибка вот тут You're here for every challenge. dopisz the memory block under the structure slowo but do not do anything with the blocks that have been identified on previous challenges dopisz♪ This memory goes to the fund to support starving Africa and never comes back!Now function dopiszI'm out of the fact that the code above it can't be changed. ♪ dopisz You must perform three actions:Increase the number of indicators lista.s one elementcreate a memory block for one slowo and release the indicator at the end lista.scopy the entry slowo to the newly established.Actions 1 and 2 are logically defined as a separate function:slowo ** append_slowo(slowo ** l, int new_count) { slowo ** newl = NULL; if(l &amp;&amp; new_count &gt; 1) { newl = (slowo **)realloc(l, sizeof(slowo*) * new_count); } else if(1 == new_count) { newl = (slowo **)malloc(sizeof(slowo*)); // создаем первый элемент } if(newl) { newl[new_count - 1] = (slowo *)malloc(sizeof(slowo)); } return newl; } Now function dopisz Adopt the following:int dopisz(lista* L, slowo s) { L->s = append_slowo(L->s, L->n + 1); if(L->s && memcpy(L->s[L->n], &s)) { ++L->n; L->jak_posortowana = BRAK; return 1; } return 0; }

int* array = malloc(sizeof(int) * argc); - here you're putting a mass of three whole numbers.int len = read_array_from_file(array, atoi(argv[1]), filename); - and here you seem to read more than three.int *arrayB = (int *)malloc(sizeof(int)); - There's only one whole in here, too.

You've got a wrong list. Instead of pointing at first location, you identified the local object of the knot.int main() { struct dirlist list, *curr; ^^^^^^^^^^^^^^^^^^^ It's not usually done. Either an additional structure is in place which contains an index to the first part of the list, or an index to the first line of the list as the list itself.In addition, the field of structure has not been initiated. For example list->next not assigned to an equal nil.I mean, the list's not real.In your case, the knots need to be removed as follows:struct dirlist * freeList( struct dirlist *dlist ) { struct dirlist *curr = dlist->next; while ( curr ) { struct dirlist *tmp = curr; curr = curr-&gt;next; free( tmp-&gt;name ); free( tmp ); } free( dlist-&gt;name ); dlist-&gt;next = nullptr; return dlist; } You should have shown the full code how the nodes are added to the list. Also if it's really C++ code, you should use new operators and delete, not malloc and free functions.

You need to use the function. reallocas defined in the heading <stdlib.h>if it turns out that the memory or number of elements in the dynamic area is not sufficient.Another approach is to use a list that you will either write yourself or take someone's ready implementation. Standard C does not specify the lists.

Transferring the memory that has already been released to function is obviously wrong. Never wrote to JNI, but we'll try to figure it out.Reading. http://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/functions.html#NewStringUTF and see that NewStringUTF returns the formed Java string object. Let's hope it's passed. Copy that. somewhere inside JVM. Then the code may look like: jstring Java_com_mycompany_myndkapp_HelloJni_stringFromJNI( JNIEnv* env, jobject thiz ) { char *result = getstring(); jstring res = (*env)->NewStringUTF(env, result); // Когда под переменную выделена память с помощью malloc, то переменную надо освобождать // ОК -- надеемся, что содержимое result[] скопировано free(result); // а res (Java string object) возвратится в джаву return res; } Try, suddenly, I guessed.

Not a serious answer:Add the following comment://Кто забудет вызвать free() для полученного //отсюда указателя будет уволен на месте! More serious answer:In the old-fashioned DOOM, the mechanism called https://doom.fandom.com/wiki/Zone_memory ♪ The idea was that memory was dynamically separated from the common pool, and then when the game was moving between levels, and the data were definitely not needed - memory was cleaned up.You can do the same, point out in the work of the annex at some point when all the lines identified have clearly been overtaken by events and take them down once.

No.M[0] = a; (it's just an attachment to the indexes, not a copyingstrcpy(M[0],a); Your appropriation is the one that leaks the memory. allocated memory is lost forever, and then 2. You try to free memory from the glacier, while free Applicable only to memory malloc♪

Challenge:"I want to remove the last symbol of the M.You've got M[index_M] = small; There's a lot going on in one place. But for nothing more than the press on the screen, M[] is not used.It's logical here to assign "element without the last symbol."How would I do that? // "на коленке" считаем длинну строки int small_len=0; while(!small[small_len++]); small_len--; // если длинна больше 1 - то откусываем последний символ и делаем присваивание if (small_len&gt;1){ small[small_len-1]=0; M[index_M] = small; index_M++; } See if you're trying to run some kind of example, maybe I didn't make a.

You're changing the name of the local area.words[i] = tmp; ♪ and you need to copy the line from one memory point to another ♪strcpy(words[i],tmp); You have no right to remove the local area, you have not given memory to it.free(words); All the memory you've given, the one you refuse.for(int i = 0; i < words_N ; i++) free (words[i]); The memory is small, short for the end of the line '\00'words[i] = (char *)malloc(sizeof(char)*(strlen(tmp) + 1)); To finish the line, make a key word, and stop as convenient.if (strlen(tmp) == 1 && tmp[0] == 'X') { words_N = i ; break; } // gcc -std=c11 -Wall -Wextra -Wpedantic -Winline -Os words.c -o words #include <stdio.h> #include <string.h> #include <ctype.h> #include <stdlib.h> #define WORDS_ARRAY_SIZE 100 #define MAX_STR_LEN 50 int main(){ char* words[WORDS_ARRAY_SIZE]; for (int i = 0; i &lt; WORDS_ARRAY_SIZE; i++) { words[i] = NULL; } char tmp[MAX_STR_LEN];//временный массив для слова int words_N = WORDS_ARRAY_SIZE ; for(int i = 0; i &lt; WORDS_ARRAY_SIZE ; i++){ scanf("%s", tmp); // ключевое слово сделайте "X" для выхода if (strlen(tmp) == 1 &amp;&amp; tmp[0] == 'X') { words_N = i ; break; } //узнаю размер слова в массиве tmp и увеличиваю words[i] // память выделяли мало, не хватает для конечного символа конца строки '\00' words[i] = (char )malloc(sizeof(char)(strlen(tmp) + 1)); if(words[i] == NULL){ printf("faill"); exit(0); } // указатель на выделенную память вы меняете на адрес локального массива // words[i] = tmp; // копируем строку из tmp в words[i] strcpy(words[i],tmp); } // free(words); // удалять локальный массив вы не имеете права, вы память для него не выделяли // всю память, что вы выделяли, от той и отказывайтесь for(int i = 0; i &lt; words_N ; i++) free (words[i]); return 0; }

Starting the mass counts[n] for cell counters in line. For the inserted number xrow = x % 10; a[row][counts[row]++] = x;

I don't know what to do with char*.I've even answered that question. There's a lot of building in the si that needs to be able to work with arithmetic indexes. Every time the index is increased by 1, its actual address under the hood shall be increased by the size of the type to which the index indicates.I mean, if we have an int index.int * a = .... By doing that.a++; The index itself (which is the number) is likely to increase by 4 (as the sizeof(int) 4 in many cases the normal software player will encounter, the truth on the ardoinc is 2).If we take it. void*it's a little more complicated - sizeof(void) is not defined. So he doesn't have an address arithmetic. And without that, there's nowhere to be done. I mean, with a si with an index on void* can only transfer more (e.g. copying) to some type or release memory. It is very difficult to record (without the types).Reading the CS Style post, why used to use a ghost in the char, but I don't know what that means now? Well, that's why it's necessary in char*, we can use the type void*, and even any type, but almost all the originals see the same char*. Or char *ptr = new char(10).Oh, it's all right. You can write in a si. char *ptr = malloc(10); And you don't have to make a special introduction. The compiler understands perfectly that void* can do char*. It also mentions in this piece and with ++ the method of remembrance, but it's highly typical, new char[10] returns the index to char*♪char* is so universal, the same void* is more logical to take?It's still more interesting. On the one hand, he represents the white, the minimum address unit (star sizeof(char) strictly 1), and on the other hand represents the symbol, and the symbols are the most common way to present the row. That's what I think and all the trouble. Plus the uncertainty with the sign... It's s++. https://en.cppreference.com/w/cpp/types/byte But as I am, it's a very and very stunning decision.Uh, you had to do a char and byte first and there wouldn't be a problem with the withdrawal. But it's been late. It's how much it's been in every field that doesn't drink it.But despite this, the char continues to be one of the most popular and demanding types.But the founders of the standard don't work. For example, there's a problem like a calambour of typicalization. If it's very rude, not just one type of indicator can be taken and lead to another type of indicator and then used safely. But... char* and void* They're standing on the side, and they're allowed a lot of things.Let's do it.void* It's hard to use 'cause the result. sizeof(void) not defined, which prevents the operation of the arithmetics of the indicators and masses.char It's not just the symbols, but it's the performance of the bikes, though everyone's trying to get away with their hands and legs in the public, but they keep using.char may be both fabulous and unmarked and nothing can be done. unsigned char and signed char Looks like two kinds of orphans.

The number three isn't quite the same number, which means the resources that I've read say that I'm not going to have one memory loss, but two.No, absolutely wrong. Show me what you read. Maybe you're missing some words.It's likely void* a=malloc(3) you'll share 4 byte and more as a convenient memory manager. He has overhead charges for a memory block that can be much higher.Am I thinking right?Not sure:Do you need to make the equating on the length of the white machine word WORD? or the double word DWORD?I don't know. Sometimes on the line of 4 bytes, sometimes 8. We have to look at each case. But it's usually almost always enough to level at 16. There are cases where they equal 1024.Suppose I found out the value of equating =2, which means I can equal everything that's short 2 or just 2?Not every single thing that's divided into two.Question-bonus is used for SSE? 8 registers each with 2 bayta and type 8*2=16?A lot of SSE instructions either won't work, or they'll be backed up, unless the data is levelled. Yeah, for some people, it's at 16 bytes, if that's what the documentation says.

There's a way to level memory. Equation is always overexpenditure, but it's necessary to make an effective use of the kash. In addition, some systems cannot correctly use if the double word is on two memory pages at the same time, an exception. An exception could be processed by an additional programme which allowed the conflict to -- but such treatment significantly slowed the programme. Equation is used to ensure that the programme does not slow down.// allocate aligned memory void *internal_align_malloc(size_t size, size_t n) This size is the size of the block that will receive the program. n is the level of equity.I'll show you the 4.Адрес Нужный адрес Итог addr + n - 1) & (~(n - 1)) x100 Выделено 0 0 или 4 4 или 8 байт 4 104 (4)8 1 4..7 5 байт 4 101 7 2 4..7 6 байт 4 102 6 3 4..7 7 байт 4 103 5 Since the difference between 7 and 8 is not large, the case of 0 (Otogo 4) is generally not used because the algorithm is complicated. A simpler option 4 (outcome is applied. The outcome means how much it takes to keep a 4-bite low.It turns out that if we have a four-bate equalization, it's gonna take four to eight byte. But we'll get the address on the way out, and we don't know what size we're gonna have, so we're taking it to the maximum with the spare. So, we're asking for 8 byte, after processing, there'll be four, and four will go to overhead. Even though the first program got more byte, it doesn't count. The programme is considered to have received as much as it has requested by calling a function. You can give it to me again (though it's not theoretical, but practically no byte in the bayte) no less.Now we're looking for 100 whites. We're going to need between 101 and 104 byte for 100 byte. It's like we're gonna need a hundred byte across 4 bytes.Four more bikes are wasted to keep the address that returned the malloc invested to do free. That's what we got. need = 100 + 4 + 4 = 108♪ Puncture free will also have to be summoned through the envelope, the return of internal_align_malloc is an undesirable result (not all memory managers can identify a single piece in the middle of the interval, it's accepted that the address that returned malloc should be sent free.While it is often more than necessary, it is not recommended to use more if there is no function (to get a "capacity" to call it a characteristic), which will give a real memory to a given site. i.e., if 100 is allocated, 100 rather than 101, or 102. If you try to write more, you can accidentally "destruct your memory" and the program will fly or work incorrectly.If you have to remembrance more, there are two algorithms (a) to create a new era of memory, and to re-copulate the old, old section to free. (b) to call relloc "realloc" if that function is available. (In fact, relloc makes the first).Theoretically-Baythic statues can be used, but in practice they rarely do so because if the station is released, the statue is cancelled. But there are tumors, it's when malloc is made, and free is never. But I'm afraid the storage of every single free bayt will need at least four bays of information that can be packed, but these operations will be quite complicated, so the statues are usually not used. If you have a self-writing relloc, it's worth taking account of the rest of your tail, and if they ask to extend your memory to the balance and less, the same area can be returned.Now, as the address is recorded at the station. Let's give you an address.Then after the change, you have an address dst equal to 8. Then dst - sizeof(char*) = address 4.Pro char**♪ Transformation of indicator.Let's addr = 4. If you can record the number int, you need to translate the address to the type of indicator into int, and you need to open the index through the (star operator) to put it in value. I mean. (int*)addr - it's an indication of an address that can be revealed as int, then one can be written in. *(int*)addr = 1 or ((int*)addr)[0] = 1♪Now, we want to write down the index. char *ptr (pr) He has a type. char*♪ To record ptr at the address, you need to get an address to the type indicator. char*, i.e. (char**)addr♪ Total attribution can be done *(char**)(addr)=ptr♪ Now, instead of addr, the phrase dst - sizeof(char*) and received *(char**)(dst - sizeof(char*)) = ptr♪

malloc(100) It's worth 100 bytes to your needs (yes, it could be 200, but it's a personal matter of memory manager). Usually, memory leads to a convenient index, for example, int*int* m = (int*)malloc(100); (I can't remember clearly, there's a little other rules and there's a way to write that. int* m = malloc(100);)As a result, there will be a memory of 25 elements of type int. (sighs)sizeof(int) It's usually 4 on most of the platforms you'll encounter. Even though Arduino Uno (ATMega) int has a size of two bayta... So there's gonna be a mass of 50 elements.Here's the design of the species. int b=(int)malloc(100) It's a fire game. The point is, on 64-bit platforms (Intel x64), the index has a size of 8 byte, and int - Four bikes, and with this, the address will be lost. And then that's the number unless it's appropriate for the withdrawal. But on platforms where sizeof(int) == sizeof(int*) - it's going to work.Now let's see this.void* C = (void*)((int)b + sizeof(void*)) Now it's starting to be cleared. An address arithmetic is working for the indicator. And if there is one.int* a = .....; a+=1; the actual address recorded in a will increase per unit, and sizeof(int)♪But here we go. void* The story is different. The thing is, sizeof(void) not defined and the arithmetic of the indicators does not work. And in the example above, it seems like (yeah, exactly) they tried to make a rhythmetic of the sign-in-law. Why, who knows him needs to be seen in the code. But he'll definitely only work where sizeof(int)>=sizeof(int*)♪Am I right to think that this attachment (int)malloc gives us the exact same address (for the requested of 100) only the number,On some plaphomas, it might be a stretch.And with the help of it, we can also add to it, so let me not need 100, and 110, we're adding 10 to b (93234923 + 10=93234933) and then we'll going back to where I' I've got?No, it doesn't work like that. The arithmetic of the indexes makes it impossible to distinguish more memory. It's just a memory index. Adding a number, just getting the address of the next memory cell. And if you go beyond your memory, it might be bad.But if you need more memory, you can just do it. realloc♪P. S. malloc - it's cherry. It's not worth using them on the plus side. Got it. new/new[]