long-integer

In the GLib documentation, there is a chapter on type conversion macros. In the discussion on converting an int to a *void pointer it says (emphasis mine): Naively, you might try this, but it's incorrect: gpointer p; int i; p = (void*) 42; i = (int) p; Again, that example was not correct, don't copy it. The problem is that on some systems you need to do this: gpointer p; int i; p = (void*) (long) 42; i = (int) (long) p; (source: GLib Reference Manual for GLib 2.39.92, chapter Type Conversion Macros ). Why is that cast to long necessary? Should any required widening of the int not happen

I know some software shops have been burned by using the int type for the primary key of a persistent class. That being said, not all tables grow past 2 billions. As a matter of fact, most don't. So, do you guys use the long type only for those classes that are mapped to potentially large tables OR for every persistent class just to be consistent? What's the industry concensus? I'll leave this question open for a while so that you can share with us your success/horror stories. Long can be advantageous even if the table does not grow super large, yet has a high turnover ie if rows are deleted

I'm trying to implement RC4 and DH key exchange in python. Problem is that I have no idea about how to convert the python long/int from the key exchange to the byte array I need for the RC4 implementation. Is there a simple way to convert a long to the required length byte array? Update : forgot to mention that the numbers I'm dealing with are 768 bit unsigned integers. I haven't done any benchmarks, but this recipe "works for me". The short version: use '%x' % val , then unhexlify the result. The devil is in the details, though, as unhexlify requires an even number of hex digits, which %x

As I've learned recently, a long in C/C++ is the same length as an int. To put it simply, why? It seems almost pointless to even include the datatype in the language. Does it have any uses specific to it that an int doesn't have? I know we can declare a 64-bit int like so: long long x = 0; But why does the language choose to do it this way, rather than just making a long well...longer than an int? Other languages such as C# do this, so why not C/C++? When writing in C or C++, every datatype is architecture and compiler specific. On one system int is 32, but you can find ones where it is 16 or

How can I make it so that the progress bar slowly goes down with the time limit? class GamePanel extends JPanel implements MouseListener, ActionListener { private JButton quit; private JButton q; private Font loadFont; public GamePanel() { setBackground(Color.blue); // sets background color this.setLayout(null); quit = new JButton("Quit"); quit.addActionListener(this); quit.setBounds(550, 700, 100, 30); this.add(quit); q = new JButton("Questions"); q.addActionListener(this); q.setBounds(100, 100, 120, 30); this.add(q); loadFont = new Font("Serif", Font.PLAIN, 30); } public void paintComponent

I have been playing around with SQL and databases in C# via SqlCeConnection . I have been using ExecuteReader to read results and BigInt values for record IDs which are read into Longs. Today I have been playing with SQL statements that use COUNT based statements ('SELECT COUNT(*) FROM X') and have been using ExecuteScalar to read these single valued results. However, I ran into an issue. I can't seem to store the values into a Long data type, which I have been using up to now. I can store them into Int64's. I have been using BigInt for record IDs to get the maximum potential number of records