Call it like this:

    foo(*ob);

Note that there is no casting going on here, as suggested in your question title. All we have done is de-referenced the pointer to the object which we then pass to the function.

    foo(*ob);

You don&#39;t need to cast it because it&#39;s the same Object type, you just need to dereference it.

&lt;!----------------------------------------------------&gt;

is there anyway i could trigger a change event on select box on page load and select a particular option. 

Also the function executed by adding the trigger after binding the function to the event.

I was trying to output something like [this][1]

    &lt;select class=&quot;check&quot;&gt;
    &lt;option value=&quot;one&quot;&gt;one&lt;/option&gt;
    &lt;option value=&quot;two&quot;&gt;two&lt;/option&gt;
    &lt;/select&gt;

    $(function(){
        $(&#39;.check&#39;).trigger(&#39;change&#39;); //This event will fire the change event. 
        $(&#39;.check&#39;).change(function(){
          var data= $(this).val();
          alert(data);            
        });
    });

http://jsfiddle.net/v7QWd/1/


  [1]: http://jsfiddle.net/v7QWd/1/

Trigger change event &lt;select&gt; using jquery

In the query below:

    SELECT column 
    FROM table
    LIMIT 18 OFFSET 8

how many results will we get as output and from where to where?







Which rows are returned when using LIMIT with OFFSET in MySQL?

How can I pass a pointer (`Object *ob`) to a function which prototype is `void foo(Object &amp;)` ?

How to cast/convert pointer to reference in C++

<p>How can I pass a pointer (<code>Object *ob</code>) to a function which prototype is <code>void foo(Object &#x26;)</code> ?</p>


I search for a good way to copy a file (binary or text). I&#39;ve written several samples, everyone works. But I want hear the opinion of seasoned programmers.

I missing good examples and search a way which works with C++.


**ANSI-C-WAY**

    #include &lt;iostream&gt;
    #include &lt;cstdio&gt;    // fopen, fclose, fread, fwrite, BUFSIZ
    #include &lt;ctime&gt;
    using namespace std;
    
    int main() {
    	clock_t start, end;
    	start = clock();
    
    	// BUFSIZE default is 8192 bytes
    	// BUFSIZE of 1 means one chareter at time
    	// good values should fit to blocksize, like 1024 or 4096
    	// higher values reduce number of system calls
    	// size_t BUFFER_SIZE = 4096;
    
    	char buf[BUFSIZ];
    	size_t size;
    
    	FILE* source = fopen(&quot;from.ogv&quot;, &quot;rb&quot;);
    	FILE* dest = fopen(&quot;to.ogv&quot;, &quot;wb&quot;);
    
    	// clean and more secure
    	// feof(FILE* stream) returns non-zero if the end of file indicator for stream is set
    
    	while (size = fread(buf, 1, BUFSIZ, source)) {
    		fwrite(buf, 1, size, dest);
    	}
    
    	fclose(source);
    	fclose(dest);
    
    	end = clock();
    
    	cout &lt;&lt; &quot;CLOCKS_PER_SEC &quot; &lt;&lt; CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME START &quot; &lt;&lt; start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END &quot; &lt;&lt; end &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END - START &quot; &lt;&lt; end - start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;TIME(SEC) &quot; &lt;&lt; static_cast&lt;double&gt;(end - start) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    
    	return 0;
    }


**POSIX-WAY** (K&amp;R use this in &quot;The C programming language&quot;, more low-level)

    #include &lt;iostream&gt;
    #include &lt;fcntl.h&gt;   // open
    #include &lt;unistd.h&gt;  // read, write, close
    #include &lt;cstdio&gt;    // BUFSIZ
    #include &lt;ctime&gt;
    using namespace std;
    
    int main() {
    	clock_t start, end;
    	start = clock();
    
    	// BUFSIZE defaults to 8192
    	// BUFSIZE of 1 means one chareter at time
    	// good values should fit to blocksize, like 1024 or 4096
    	// higher values reduce number of system calls
    	// size_t BUFFER_SIZE = 4096;
    	
    	char buf[BUFSIZ];
    	size_t size;
    
    	int source = open(&quot;from.ogv&quot;, O_RDONLY, 0);
    	int dest = open(&quot;to.ogv&quot;, O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);
    
    	while ((size = read(source, buf, BUFSIZ)) &gt; 0) {
    		write(dest, buf, size);
    	}
    
    	close(source);
    	close(dest);
    
    	end = clock();
    
    	cout &lt;&lt; &quot;CLOCKS_PER_SEC &quot; &lt;&lt; CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME START &quot; &lt;&lt; start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END &quot; &lt;&lt; end &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END - START &quot; &lt;&lt; end - start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;TIME(SEC) &quot; &lt;&lt; static_cast&lt;double&gt;(end - start) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    
    	return 0;
    }


**KISS-C++-Streambuffer-WAY**

    #include &lt;iostream&gt;
    #include &lt;fstream&gt;
    #include &lt;ctime&gt;
    using namespace std;
    
    int main() {
    	clock_t start, end;
    	start = clock();
    
    	ifstream source(&quot;from.ogv&quot;, ios::binary);
    	ofstream dest(&quot;to.ogv&quot;, ios::binary);
    
    	dest &lt;&lt; source.rdbuf();
    
    	source.close();
    	dest.close();
    
    	end = clock();
    
    	cout &lt;&lt; &quot;CLOCKS_PER_SEC &quot; &lt;&lt; CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME START &quot; &lt;&lt; start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END &quot; &lt;&lt; end &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END - START &quot; &lt;&lt;  end - start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;TIME(SEC) &quot; &lt;&lt; static_cast&lt;double&gt;(end - start) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    
    	return 0;
    }


**COPY-ALGORITHM-C++-WAY**

    #include &lt;iostream&gt;
    #include &lt;fstream&gt;
    #include &lt;ctime&gt;
    #include &lt;algorithm&gt;
    #include &lt;iterator&gt;
    using namespace std;
    
    int main() {
    	clock_t start, end;
    	start = clock();
    
    	ifstream source(&quot;from.ogv&quot;, ios::binary);
    	ofstream dest(&quot;to.ogv&quot;, ios::binary);
    
    	istreambuf_iterator&lt;char&gt; begin_source(source);
    	istreambuf_iterator&lt;char&gt; end_source;
    	ostreambuf_iterator&lt;char&gt; begin_dest(dest);	
    	copy(begin_source, end_source, begin_dest);
    
    	source.close();
    	dest.close();
    
    	end = clock();
    
    	cout &lt;&lt; &quot;CLOCKS_PER_SEC &quot; &lt;&lt; CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME START &quot; &lt;&lt; start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END &quot; &lt;&lt; end &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END - START &quot; &lt;&lt;  end - start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;TIME(SEC) &quot; &lt;&lt; static_cast&lt;double&gt;(end - start) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    
    	return 0;
    }


**OWN-BUFFER-C++-WAY**

    #include &lt;iostream&gt;
    #include &lt;fstream&gt;
    #include &lt;ctime&gt;
    using namespace std;
    
    int main() {
    	clock_t start, end;
    	start = clock();
    
    	ifstream source(&quot;from.ogv&quot;, ios::binary);
    	ofstream dest(&quot;to.ogv&quot;, ios::binary);
    
    	// file size
    	source.seekg(0, ios::end);
    	ifstream::pos_type size = source.tellg();
    	source.seekg(0);
    	// allocate memory for buffer
    	char* buffer = new char[size];
    
    	// copy file	
    	source.read(buffer, size);
    	dest.write(buffer, size);
    
    	// clean up
    	delete[] buffer;
    	source.close();
    	dest.close();
    	
    	end = clock();
    
    	cout &lt;&lt; &quot;CLOCKS_PER_SEC &quot; &lt;&lt; CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME START &quot; &lt;&lt; start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END &quot; &lt;&lt; end &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END - START &quot; &lt;&lt;  end - start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;TIME(SEC) &quot; &lt;&lt; static_cast&lt;double&gt;(end - start) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    
    	return 0;
    }

  
**LINUX-WAY** // requires kernel &gt;= 2.6.33

    #include &lt;iostream&gt;
    #include &lt;sys/sendfile.h&gt;  // sendfile
    #include &lt;fcntl.h&gt;         // open
    #include &lt;unistd.h&gt;        // close
    #include &lt;sys/stat.h&gt;      // fstat
    #include &lt;sys/types.h&gt;     // fstat
    #include &lt;ctime&gt;
    using namespace std;
    
    int main() {
    	clock_t start, end;
    	start = clock();
    
    	int source = open(&quot;from.ogv&quot;, O_RDONLY, 0);
    	int dest = open(&quot;to.ogv&quot;, O_WRONLY | O_CREAT /*| O_TRUNC/**/, 0644);
    
    	// struct required, rationale: function stat() exists also
    	struct stat stat_source;
    	fstat(source, &amp;stat_source);
    
    	sendfile(dest, source, 0, stat_source.st_size);
    
    	close(source);
    	close(dest);
    
    	end = clock();
    
    	cout &lt;&lt; &quot;CLOCKS_PER_SEC &quot; &lt;&lt; CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME START &quot; &lt;&lt; start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END &quot; &lt;&lt; end &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;CPU-TIME END - START &quot; &lt;&lt;  end - start &lt;&lt; &quot;\n&quot;;
    	cout &lt;&lt; &quot;TIME(SEC) &quot; &lt;&lt; static_cast&lt;double&gt;(end - start) / CLOCKS_PER_SEC &lt;&lt; &quot;\n&quot;;
    
    	return 0;
    }

**Environment**  

 - GNU/LINUX (Archlinux)
 - Kernel 3.3
 - GLIBC-2.15, LIBSTDC++ 4.7 (GCC-LIBS), GCC 4.7, Coreutils 8.16
 - Using RUNLEVEL 3 (Multiuser, Network, Terminal, no GUI)
 - INTEL SSD-Postville 80 GB, filled up to 50%  
 - Copy a 270 MB OGG-VIDEO-FILE  

**Steps to reproduce** 

     1. $ rm from.ogg
     2. $ reboot                           # kernel and filesystem buffers are in regular
     3. $ (time ./program) &amp;&gt;&gt; report.txt  # executes program, redirects output of program and append to file
     4. $ sha256sum *.ogv                  # checksum
     5. $ rm to.ogg                        # remove copy, but no sync, kernel and fileystem buffers are used
     6. $ (time ./program) &amp;&gt;&gt; report.txt  # executes program, redirects output of program and append to file



 


**Results (CPU TIME used)**  
  
    Program  Description                 UNBUFFERED|BUFFERED
    ANSI C   (fread/frwite)                 490,000|260,000  
    POSIX    (K&amp;R, read/write)              450,000|230,000  
    FSTREAM  (KISS, Streambuffer)           500,000|270,000 
    FSTREAM  (Algorithm, copy)              500,000|270,000
    FSTREAM  (OWN-BUFFER)                   500,000|340,000  
    SENDFILE (native LINUX, sendfile)       410,000|200,000  

Filesize doesn&#39;t change.  
sha256sum print the same results.  
The video file is still playable.  



**Questions**

 - What method would you prefer?
 - Do you know better solutions?
 - Do you see any mistakes in my code?
 - Do you know a reason to avoid a solution?

 - FSTREAM (KISS, Streambuffer)  
I really like this one, because it is really short and simple. As far is I know the operator &lt;&lt; is overloaded for rdbuf() and doesn&#39;t convert anything. Correct?


Thanks


**Update 1**  
I changed the source in all samples in that way, that the open and close of the file descriptors is include in the measurement of *clock()*. Their are no other significant changes in the source code. The results doesn&#39;t changed! I also used *time* to double-check my results.  

**Update 2**  
ANSI C sample changed: The condition of the *while-loop* doesn&#39;t call any longer *feof()* instead I moved *fread()* into the condition. It looks like, the code runs now 10,000 clocks faster.  

Measurement changed: The former results were always buffered, because I repeated the old command line *rm to.ogv &amp;&amp; sync &amp;&amp; time ./program* for each program a few times. Now I reboot the system for every program. The unbuffered results are new and show no surprise. The unbuffered results didn&#39;t changed really.

If i don&#39;t delete the old copy, the programs react different. Overwriting a existing file *buffered* is faster with POSIX and SENDFILE, all other programs are slower. Maybe the options *truncate* or *create* have a impact on this behaviour. But overwriting existing files with the same copy is not a real world use-case.  

Performing the copy with *cp* takes 0.44 seconds unbuffered und 0.30 seconds buffered. So *cp* is a little bit slower than the POSIX sample. Looks fine for me.  


Maybe I add also samples and results of *mmap()* and *`copy_file()`* from boost::filesystem.

**Update 3**  
I&#39;ve put this also on a blog page and extended it a little bit. Including *splice()*, which is a low-level function from the Linux kernel. Maybe more samples with Java will follow.
http://www.ttyhoney.com/blog/?page_id=69

Copy a file in a sane, safe and efficient way

&gt; **Possible Duplicate:**  
&gt; [size of int, long, etc](https://stackoverflow.com/questions/589575/size-of-int-long-etc)  
&gt; [Does the size of an int depend on the compiler and/or processor?](https://stackoverflow.com/questions/2331751/does-the-size-of-an-int-depend-on-the-compiler-and-or-processor)  
&gt; [What decides the sizeof an integer?](https://stackoverflow.com/questions/9689049/what-decides-the-sizeof-an-integer)  

&lt;!-- End of automatically inserted text --&gt;

I&#39;m using a `64-bit` machine.

    $ uname -m
    x86_64
    $ file /usr/bin/file
    /usr/bin/file: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, stripped
    $ 

When I ran the following program, I got the `sizeof(int)` as `4-bytes`.

    #include &lt;stdio.h&gt;
    
    int main(void)
    {
        printf(&quot;sizeof(int) = %d bytes\n&quot;, (int) sizeof(int));
    
        return 0;
    }

If I&#39;m running a `16-`, `32-` and `64-` bit machine, then doesn&#39;t it mean that the size of an `integer` is `16-`, `32-` and `64-` bit respectively?

In my machine, I found the `WORD_BIT` is `32`. Shouldn&#39;t it be `64` on a `64-bit` machine? 

    $ getconf WORD_BIT
    32
    $ 

And, shouldn&#39;t the `sizeof(int)` be `64-bits` (`8 bytes`) in the above case?

What should be the sizeof(int) on a 64-bit machine?

In C++, if a constructor throws an exception, what destructors are run?

In particular, does it make any difference if the exception is during the initialization list or the body?

Also, what about inheritance and members?  Presumably all completed constructions get destructed.  If only some members are constructed, do only those get destructed?  If there is multiple inheritance, do all completed constructors get destructed?  Does virtual inheritance change anything?

What destructors are run when the constructor throws an exception?

I&#39;m trying to do something very simple and yet, after an hour of so of searching a I can&#39;t find a suitable answer so I must be missing something fairly obvious.

I&#39;m trying to dynamically create filenames for use with ifstream. Whilst I understand various methods are available of doing this, I have settled on creating a std::string, and the using stringname.c_str to convert to const.

The problem is however that I need to create the string with a mix of variables and predefined text values. I&#39;m getting compiler errors, so this must be a syntax issue.

Pseudo 

    std::string var = &quot;sometext&quot; + somevar + &quot;sometext&quot; + somevar;

Thanks!

C++ create string of text and variables

I heard a recent talk by Herb Sutter who suggested that the reasons to pass `std::vector` and `std::string` by `const &amp;` are largely gone.  He suggested that writing a function such as the following is now preferable:

    std::string do_something ( std::string inval )
    {
       std::string return_val;
       // ... do stuff ...
       return return_val;
    }

I understand that the `return_val` will be an rvalue at the point the function returns and can therefore be returned using move semantics, which are very cheap.  However, `inval` is still much larger than the size of a reference (which is usually implemented as a pointer).  This is because a `std::string` has various components including a pointer into the heap and a member `char[]` for short string optimization.  So it seems to me that passing by reference is still a good idea.

Can anyone explain why Herb might have said this?

Are the days of passing const std::string &amp; as a parameter over?

I am trying to understand pointers in C but I am currently confused with the following:

- 
        char *p = &quot;hello&quot;

 This is a char pointer pointing at the character array, starting at _h_.

- 
        char p[] = &quot;hello&quot;

 This is an array that stores _hello_.

What is the difference when I pass both these variables into this function?

    void printSomething(char *p)
    {
        printf(&quot;p: %s&quot;,p);
    }


What is the difference between char array and char pointer in C?

Under which circumstances would you want to use code of this nature in c++?

    void foo(type *&amp;in) {...}
    
    void fii() {
      type *choochoo;
      ...
      foo(choochoo);
    }

Reason to Pass a Pointer by Reference in C++?

I read in a few articles that raw pointers should almost never be used. Instead they should always be wrapped inside smart pointers, whether it&#39;s scoped or shared pointers.

However, I noticed that frameworks like Qt, wxWidgets and libraries like Boost never return nor expect smart pointers, as if they were not using them at all. Instead, they return or expect raw pointers. Is there any reason for that? Should I stay away from smart pointers when I write a public API, and why?

Just wondering why smart pointers are recommended when many major projects seem to avoid them.

Why do C++ libraries and frameworks never use smart pointers?

What&#39;s the cleanest way to handle a case such as this:

    func a() string {
        /* doesn&#39;t matter */
    }
    
    b *string = &amp;a()

This generates the error:

&gt; cannot take the address of a()

My understanding is that Go automatically promotes a local variable to the heap if its address is taken. Here it&#39;s clear that the address of the return value is to be taken. What&#39;s an idiomatic way to handle this?

Address of a temporary in Go?

Doesn&#39;t `std::unique_ptr::get` defeat the purpose of having a unique_ptr in the first place?
I would have expected this function to change its state so it holds no more pointer.
Is there an actual useful use of std::unique_ptr::get?

what&#39;s the point of std::unique_ptr::get

How can I discard/round the `millisecond` part, better if the `second` part is also removed from a `timestamp` w/o `timezone` ?

Discard millisecond part from timestamp

Similar to https://stackoverflow.com/questions/29482/cast-int-to-enum-in-c-sharp but my enum is a Generic Type parameter.  What is the *best* way to handle this?

Example:

    private T ConvertEnum&lt;T&gt;(int i) where T : struct, IConvertible
    {
        return (T)i;
    }

Generates compiler error `Cannot convert type &#39;int&#39; to &#39;T&#39;`


Full code is as follows, where value can contain the int, or null.

    private int? TryParseInt(string value)
    {
        var i = 0;
        if (!int.TryParse(value, out i))
        {
            return null;
        }
        return i;
    }
    
    private T? TryParseEnum&lt;T&gt;(string value) where T : struct, IConvertible
    {
        var i = TryParseInt(value);
        if (!i.HasValue)
        {
            return null;
        }
    
        return (T)i.Value;
    }

Cast Int to Generic Enum in C#

I&#39;m trying to debug a program I inherited. This program contains Strings, array lists and collections, lots of casting between types, and I need to do some String manipulations (`substring`, etc.) 

The data _look_ like Strings when printed to the console (e.g., it&#39;s a line of text, like `Johnson, John` or `Chicago Region`), but my code is erroring out with various `index out of range` errors, suggesting that my code to cast to String isn&#39;t working. 

I&#39;d like to try to figure out what data types are coming into and leaving my methods to verify that the program is acting as expected. Is there any way to find a field type in Java? In a perfect world, I could generate console output at every step that would give me the data value and whether it&#39;s a String, array list, or collection. Can that be done?

Is there a way to output the java data type to the console?

I want to accomplish the following

    answer = True
    myvar = &quot;the answer is &quot; + answer

and have myvar&#39;s value be &quot;the answer is True&quot;. I&#39;m pretty sure you can do this in Java.

How do I concatenate a boolean to a string in Python?

I want to determine if a value is integer (like `TryParse` in .NET). Unfortunatelly `ISNUMERIC` does not fit me because I want to parse only integers and not every kind of number. Is there such thing as `ISINT` or something?

Here is some code to make things clear. If `MY_FIELD` is not int, this code would fail:

    SELECT @MY_VAR = CAST(MY_FIELD AS INT)
    FROM MY_TABLE
    WHERE MY_OTHER_FIELD = &#39;MY_FILTER&#39;

Thank you

T-sql - determine if value is integer

I&#39;m having a little trouble understanding the pass-by-reference properties of `data.table`. Some operations seem to &#39;break&#39; the reference, and I&#39;d like to understand exactly what&#39;s happening.

On creating a `data.table` from another `data.table` (via `&lt;-`, then updating the new table by `:=`, the original table is also altered. This is expected, as per:

`?data.table::copy`
and [stackoverflow: pass-by-reference-the-operator-in-the-data-table-package](&lt;https://stackoverflow.com/questions/8030452/pass-by-reference-the-operator-in-the-data-table-package&gt;)

Here&#39;s an example:

    library(data.table)

    DT &lt;- data.table(a=c(1,2), b=c(11,12))
    print(DT)
    #      a  b
    # [1,] 1 11
    # [2,] 2 12

    newDT &lt;- DT        # reference, not copy
    newDT[1, a := 100] # modify new DT

    print(DT)          # DT is modified too.
    #        a  b
    # [1,] 100 11
    # [2,]   2 12

However, if I insert a non-`:=` based modification between the `&lt;-` assignment and the `:=` lines above, `DT` is now no longer modified:

    DT = data.table(a=c(1,2), b=c(11,12))
    newDT &lt;- DT        
    newDT$b[2] &lt;- 200  # new operation
    newDT[1, a := 100]

    print(DT)
    #      a  b
    # [1,] 1 11
    # [2,] 2 12

So it seems that the `newDT$b[2] &lt;- 200` line somehow &#39;breaks&#39; the reference. I&#39;d guess that this invokes a copy somehow, but I would like to understand fully how R is treating these operations, to ensure I don&#39;t introduce potential bugs in my code.

I&#39;d very much appreciate if someone could explain this to me.

Understanding exactly when a data.table is a reference to (vs a copy of) another data.table

In the code:

    y = 7
    x = y
    x = 8

Now, `y` will be 7 and x will be 8. But actually I wan to change `y`. Can I assign the reference of `y` and do that?

For example, in C++ the same thing can be achieved as:

&lt;!-- language: lang-c++ --&gt;

    int y = 8;
    int &amp;x = y;
    x = 9;

Now both `y` &amp; `x` will be 9


How to create a reference to a variable in python?

what happens when you dereference a pointer when passing by reference to a function?

Here is a simple example

    int&amp; returnSame( int &amp;example ) { return example; }

    int main()
    {
      int inum = 3;
      int *pinum = &amp; inum;
      
      std::cout &lt;&lt; &quot;inum: &quot; &lt;&lt;  returnSame(*pinum) &lt;&lt; std::endl;
     
      return 0;          

    }

Is there a temporary object produced?

dereferencing a pointer when passing by reference

&gt; **Possible Duplicate:**  
&gt; [Does a const reference prolong the life of a temporary?](https://stackoverflow.com/questions/2784262/does-a-const-reference-prolong-the-life-of-a-temporary)  

&lt;!-- End of automatically inserted text --&gt;

My compiler doesn&#39;t complain about assigning temporary to const reference:

    string foo() {
      return string(&quot;123&quot;);
    };
    
    int main() {
      const string&amp; val = foo();
      printf(&quot;%s\n&quot;, val.c_str());
      return 0;
    }

Why? I thought that string returned from `foo` is temporary and val can point to object which lifetime has finished. Does C++ standard allow this and prolongs the lifetime of returned object?

Returning temporary object and binding to const reference

A column `height` is integer type in my SQL Server table. I want to do a division and have the result as decimal in my query:

    Select (height/10) as HeightDecimal

How do I cast so that the `HeightDecimal` is no longer integer? Thanks.

How to convert integer to decimal in SQL Server query?

How to convert a `double` value to `int` doing the following:

    Double If x = 4.97542. Convert to int x = 4.
    
    Double If x = 4.23544. Convert to int x = 4.

That is, the answer is always rounding down.

Convert double to Int, rounded down

I want to convert `String` to a `Double` data type. I do not know if I should use `parseDouble` or `valueOf`.

What is the difference between these two methods?

What is the difference between Double.parseDouble(String) and Double.valueOf(String)?

So I&#39;m creating a game in XNA, C# 4.0, and I need to manage a lot of PowerUps (which in code are all inherited from class &quot;PowerUp&quot;), and to handle back-end management of the PowerUps I currently have an enum, PowerupEffectType, with a value for each child class of PowerUp. Eventually in the code I need to do conversions from PowerupEffectType to the Powerup type (of class `Type`, achieved usually with `typeof([class name])`).

Since this is a group project, I want to marry each value of PowerupEffectType to its corresponding class Type as well as possible, i.e.: Not just expect my other programmers to use switch statements to do the conversion manually, and making sure additions/expansions later involve as few changes in as few places as possible. I have a few options for this, and the best I&#39;ve discovered so far is creating enum pseudo-methods that condense everything down to a single switch statement (99% of what I want), thanks to some tips I found here: http://msdn.microsoft.com/en-us/library/bb383974.aspx

But I&#39;m trying to take it one step further - **can I save a `Type` in an `enum`?** I know you can save enums as a specific type (link: http://msdn.microsoft.com/en-us/library/cc138362.aspx), but `Type` isn&#39;t one of them. The current choices are *byte, sbyte, short, ushort, int, uint, long, and ulong*. Is there any feasible way to save a convert a `Type` to any of the above data types and back?

**Just to be clear, this is what I WISH I could do, and I&#39;m looking for a way to do:**

    // (Assuming &#39;LightningPowerup&#39;, &#39;FirePowerup&#39;, and &#39;WaterPowerup&#39; are
    // all declared classes that inherit from a single base class)
    
    public enum PowerupEffectType
    {
        LIGHTNING = typeof(LightningPowerup),
        FIRE = typeof(FirePowerup),
        WATER = typeof(WaterPowerup)
    }

Is there any way to do this, or am I just overcomplicating a solution to a problem that&#39;s already 99% complete?

Thanks in advance!

Is it possible to save a Type (using &quot;typeof()&quot;) in an enum?

I need to create a client-server example over TCP. In the client side I read 2 numbers and I send them to the server. The problem I faced is that I can&#39;t convert from `[]byte` to `int`, because the communication accept only data of type `[]byte`.

Is there any way to convert `[]byte` to `int` or I can send `int` to the server?

Some sample code will be really appreciated.

Thanks.

Content Type	Original Author	Original Content on Stackoverflow
Question	Dewsworld	View Question on Stackoverflow
Solution 1 - C++	David Heffernan	View Answer on Stackoverflow
Solution 2 - C++	Roee Gavirel	View Answer on Stackoverflow

How to cast/convert pointer to reference in C++

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Which rows are returned when using LIMIT with OFFSET in MySQL?

Trigger change event <select> using jquery

Attributions