Code::Blocks shows different result from other IDE's

User forums > Help

<< < (2/3) > >>

marky1337:
Thank you BlueHazzard for the good reply. I thought i souldn't exagerate with the information.
One computer has Windows XP SP3 32bit ::) , one has Windows 10 64bit.
Both use Code::Blocks 16.01 (from codeblocks.org) with MinGW 4.9.2.
The program compiles fine, the output is fine structurally, but it's wrong (on all of C++98/C++00/C++11), it should be a different one. I hope you understood what result i was talking about, it's the programming problem's answer.

Both the debug and the release mode output the same thing. I know what a compiler is (more or less). The other IDEs(which i now realise are more of a compiler than an IDE ::) ) i used are some online ones.
Some links to some of them (idk if it's allowed):
https://www.onlinegdb.com/online_c++_compiler
https://www.codechef.com/ide
http://cpp.sh/
https://ide.geeksforgeeks.org/

My question is more like why would that happen as long as the code is absolutely the same?

Build log:

--- Quote ----------------- Clean: Release in wtfkruskal (compiler: GNU GCC Compiler)---------------

Cleaned "wtfkruskal - Release"

-------------- Build: Release in wtfkruskal (compiler: GNU GCC Compiler)---------------

mingw32-g++.exe -Wall -fexceptions -O2 -c "D:\code blocks\wtfkruskal\main.cpp" -o obj\Release\main.o
mingw32-g++.exe -o bin\Release\wtfkruskal.exe obj\Release\main.o -s
Output file is bin\Release\wtfkruskal.exe with size 110.00 KB
Process terminated with status 0 (0 minute(s), 5 second(s))
0 error(s), 0 warning(s) (0 minute(s), 5 second(s))

--- End quote ---

BlueHazzard:

--- Quote ---My question is more like why would that happen as long as the code is absolutely the same?

--- End quote ---
It does not happen. If i copy and paste the program from your link into a codeblocks project i get exactly the same output as in the link at the bottom. (but i use gcc 5.x.x)

--- Quote ---The program compiles fine, the output is fine structurally, but it's wrong (on all of C++98/C++00/C++11), it should be a different one. I hope you understood what result i was talking about,
--- End quote ---
i still don't know what your output is....

[edit:] You can copy and paste the output of a console window. Google for it...

marky1337:

--- Quote from: BlueHazzard on February 22, 2018, 07:09:32 pm ---
--- Quote ---The program compiles fine, the output is fine structurally, but it's wrong (on all of C++98/C++00/C++11), it should be a different one. I hope you understood what result i was talking about,
--- End quote ---
i still don't know what your output is....

[edit:] You can copy and paste the output of a console window. Google for it...

--- End quote ---

The example from the site gives me a good output too but if i modify the input ( the graph ) a bit so the code will look like this (a bit long but i can't see a pop-up window in the text editor here and also i know i inserted the input by hand but i wanted the code to be as similar as the original ):

--- Code: ---// C++ program for Kruskal's algorithm to find Minimum Spanning Tree
// of a given connected, undirected and weighted graph
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// a structure to represent a weighted edge in graph
struct Edge
{
int src, dest, weight;
};

// a structure to represent a connected, undirected
// and weighted graph
struct Graph
{
// V-> Number of vertices, E-> Number of edges
int V, E;

// graph is represented as an array of edges.
// Since the graph is undirected, the edge
// from src to dest is also edge from dest
// to src. Both are counted as 1 edge here.
struct Edge* edge;
};

// Creates a graph with V vertices and E edges
struct Graph* createGraph(int V, int E)
{
struct Graph* graph = new Graph;
graph->V = V;
graph->E = E;

graph->edge = new Edge[E];

return graph;
}

// A structure to represent a subset for union-find
struct subset
{
int parent;
int rank;
};

// A utility function to find set of an element i
// (uses path compression technique)
int find(struct subset subsets[], int i)
{
// find root and make root as parent of i
// (path compression)
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);

return subsets[i].parent;
}

// A function that does union of two sets of x and y
// (uses union by rank)
void Union(struct subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);

// Attach smaller rank tree under root of high
// rank tree (Union by Rank)
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;

// If ranks are same, then make one as root and
// increment its rank by one
else
{
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}

// Compare two edges according to their weights.
// Used in qsort() for sorting an array of edges
int myComp(const void* a, const void* b)
{
struct Edge* a1 = (struct Edge*)a;
struct Edge* b1 = (struct Edge*)b;
return a1->weight > b1->weight;
}

// The main function to construct MST using Kruskal's algorithm
void KruskalMST(struct Graph* graph)
{
int V = graph->V;
struct Edge result[V]; // Tnis will store the resultant MST
int e = 0; // An index variable, used for result[]
int i = 0; // An index variable, used for sorted edges

// Step 1: Sort all the edges in non-decreasing
// order of their weight. If we are not allowed to
// change the given graph, we can create a copy of
// array of edges
qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);

// Allocate memory for creating V ssubsets
struct subset *subsets =
(struct subset*) malloc( V * sizeof(struct subset) );

// Create V subsets with single elements
for (int v = 0; v < V; ++v)
{
subsets[v].parent = v;
subsets[v].rank = 0;
}

// Number of edges to be taken is equal to V-1
while (e < V - 1)
{
// Step 2: Pick the smallest edge. And increment
// the index for next iteration
struct Edge next_edge = graph->edge[i++];

int x = find(subsets, next_edge.src);
int y = find(subsets, next_edge.dest);

// If including this edge does't cause cycle,
// include it in result and increment the index
// of result for next edge
if (x != y)
{
result[e++] = next_edge;
Union(subsets, x, y);
}
// Else discard the next_edge
}

// print the contents of result[] to display the
// built MST
printf("Following are the edges in the constructed MST\n");
for (i = 0; i < e; ++i)
printf("%d -- %d == %d\n", result[i].src, result[i].dest,
result[i].weight);
return;
}

// Driver program to test above functions
int main()
{
int V = 9; // Number of vertices in graph
int E = 14; // Number of edges in graph
struct Graph* graph = createGraph(V, E);

graph->edge[0].src = 0;
graph->edge[0].dest = 1;
graph->edge[0].weight = 10;

graph->edge[1].src = 0;
graph->edge[1].dest = 2;
graph->edge[1].weight = -11;

graph->edge[2].src = 1;
graph->edge[2].dest = 3;
graph->edge[2].weight = 11;

graph->edge[3].src = 1;
graph->edge[3].dest = 4;
graph->edge[3].weight = 11;

graph->edge[4].src = 4;
graph->edge[4].dest = 5;
graph->edge[4].weight = 13;

graph->edge[5].src = 2;
graph->edge[5].dest = 3;
graph->edge[5].weight = 10;

graph->edge[6].src = 3;
graph->edge[6].dest = 5;
graph->edge[6].weight = 12;

graph->edge[7].src = 3;
graph->edge[7].dest = 6;
graph->edge[7].weight = 5;

graph->edge[8].src = 2;
graph->edge[8].dest = 6;
graph->edge[8].weight = 4;

graph->edge[9].src = 2;
graph->edge[9].dest = 7;
graph->edge[9].weight = 5;

graph->edge[10].src = 7;
graph->edge[10].dest = 6;
graph->edge[10].weight = 5;

graph->edge[11].src = 7;
graph->edge[11].dest = 8;
graph->edge[11].weight = 4;

graph->edge[12].src = 8;
graph->edge[12].dest = 6;
graph->edge[12].weight = 3;

graph->edge[13].src = 5;
graph->edge[13].dest = 6;
graph->edge[13].weight = 11;
KruskalMST(graph);

return 0;
}

--- End code ---

The output i get in Code::Blocks:

--- Quote ---Following are the edges in the constructed MST
3 -- 6 == 5
0 -- 2 == -11
8 -- 6 == 3
7 -- 8 == 4
2 -- 3 == 10
0 -- 1 == 10
5 -- 6 == 11
1 -- 4 == 11

--- End quote ---

The output i get online which is the correct output:

--- Quote ---Following are the edges in the constructed MST
0 -- 2 == -11
8 -- 6 == 3
2 -- 6 == 4
7 -- 8 == 4
3 -- 6 == 5
0 -- 1 == 10
1 -- 4 == 11
5 -- 6 == 11

--- End quote ---

So can you try the same code out and tell me which is the output you get? I used CB for 3 and a half years now and i never encountered this odd issue.

BlueHazzard:
Now we are talking.... See? You have wasted a whole day with writing non relevant post until we finally get some code to run and inspect.... Now we can work... This is so frustrating if people tell they run "this code" and the it comes out, that they modified it and it is completely different...

Now i get also your result. The first thing i am thinking of is the web based ides run all on linux and you and me are running windows.
They are running gcc 5.4, you are running gcc4.6, i am running gcc5.1, gcc 6.4 and mingw64-gcc7.1 on all this compiler on windows the result is the same.

Now lets look at the code, where is the possibility that something goes wrong? My first guess is "qsort"

i made a breakpoint after the function call.

on windows:

--- Code: --- p graph->edge[0]
$1 = {src = 3, dest = 6, weight = 5}

p graph->edge[1]
$2 = {src = 0, dest = 2, weight = -11}

p graph->edge[2]
$3 = {src = 8, dest = 6, weight = 3}

--- End code ---

on linux:

--- Code: ---p graph->edge[0]
$2 = {src = 0, dest = 2, weight = -11}
graph->edge[1]]
$4 = {src = 8, dest = 6, weight = 3}
p graph->edge[2]]
$6 = {src = 2, dest = 6, weight = 4}

--- End code ---

there is something fishy... Just to make things clear, this is not a codeblocks problem, but a compiler, stdlib problem...
sorted list on linux:

--- Code: ---0: -11
1: 3
2: 4
3: 4
4: 5
5: 5
6: 5
7: 10
8: 10
9: 11
10: 11
11: 11
12: 12
13: 13

--- End code ---

sorted list in windows:

--- Code: ---0: 5
1: -11
2: 3
3: 4
4: 5
5: 10
6: 5
7: 10
8: 4
9: 11
10: 11
11: 11
12: 12
13: 13

--- End code ---

:o

if i use this sort function:

--- Code: --- struct {
bool operator()(const Edge a1,const Edge b1) const
{
return a1.weight < b1.weight;
}
} customLess;
std::sort(graph->edge, graph->edge + graph->E, customLess);
--- End code ---
all works as expected:

--- Code: ---0 -- 2 == -11
8 -- 6 == 3
2 -- 6 == 4
7 -- 8 == 4
3 -- 6 == 5
0 -- 1 == 10
1 -- 4 == 11
5 -- 6 == 11
--- End code ---

The question now is, why does qsort on windows does not work?....

BlueHazzard:
Ok, i know now what the problem is.... Read the documentation of qsort: http://en.cppreference.com/w/cpp/algorithm/sort

--- Quote ---comparison function which returns a negative integer value if the first argument is less than the second,

a positive integer value if the first argument is greater than the second and zero if the arguments are equal.
--- End quote ---

your compare function does not fulfill this criteria...

It seems that the qsort implementation of windows needs exactly this behavior and linux is a bit more tolerant to this...

if i implement the compare function correctly all works as expected...

[Edit:] so obfuscated was right, your code was wrong :) Remember: This question is not in the scope of this forum, because it has nothing to do with the IDE codeblocks, but with the stdlib of c

Navigation

[0] Message Index

[#] Next page

[*] Previous page

Go to full version