Wiki

User Tools

Site Tools

Trace:
c:c_const_declaration

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
c:c_const_declaration [2021/10/04 20:33] – peterc:c_const_declaration [2023/06/26 07:24] (current) – [Messier Still - in the Object Oriented Programming] peter
Line 73: Line 73:
   * Instead of a difficult to track down crash, the attempt to alter unalterable values will be detected during compilation.   * Instead of a difficult to track down crash, the attempt to alter unalterable values will be detected during compilation.
  
-For example, if a function which returns a fixed ‘Some text’ string is written like:+If a function which returns a fixed string is written like:
  
 <code cpp> <code cpp>
 char *Function1() char *Function1()
 {  { 
-  return “Some text”;+  return "Some text";
 } }
 </code> </code>
  
-then the program could crash if it accidentally tried to alter the value doing:+...then the program could crash if it accidentally tried to alter the value doing:
  
 <code cpp> <code cpp>
Line 88: Line 88:
 </code> </code>
  
-whereas the compiler would have spotted the error if the original function had been written:+**__The solution:__**
  
 <code cpp> <code cpp>
Line 97: Line 97:
 </code> </code>
  
-because the compiler would then know that the value was unalterable.+<WRAP info> 
 +**NOTE:**  The compiler will spot the error, because the compiler would then know that the value was unalterable. 
 +</WRAP>
  
 ---- ----
Line 103: Line 105:
 ===== Where it Gets Messy - in Parameter Passing ===== ===== Where it Gets Messy - in Parameter Passing =====
  
-When a subroutine or function is called with parameters, variables passed as the parameters might be read from in order to transfer data into the subroutine/function, written to in order to transfer data back to the calling program or both to do both. +==== Passing a parameter to a function by value ====
- +
-  * Some languages enable one to specify this directly, such as having ‘in:’, ‘out:’ & ‘inout:’ parameter types, whereas in C one has to work at a lower level and specify the method for passing the variables choosing one that also allows the desired data transfer direction. +
- +
-For example, a subroutine like:+
  
 <code cpp> <code cpp>
Line 116: Line 114:
 </code> </code>
  
-accepts the parameter passed to it in the default C & C++ way - which is a copy.+<WRAP info> 
 +**NOTE:**  Parameter1 is passed in the default C & C++ way - which is a copy.
  
-Therefore the subroutine can read the value of the variable passed to it but not alter it because any alterations it makes are only made to the copy and are lost when the subroutine ends. E.g.+  * The subroutine can read the value of the variable passed to it but not alter it because any alterations it makes are only made to the copy and are lost when the subroutine ends.
  
 +  * Here, the variable **original_value** would remain unchanged with a value of 5, and not be set to 96 after Subroutine2 is done.
 <code cpp> <code cpp>
 +void Subroutine1()
 +{ 
 +  original_value = 5;
 +  Subroutine2(original_value);
 +}
 +
 void Subroutine2(int Parameter1) void Subroutine2(int Parameter1)
 {  { 
Line 127: Line 133:
 </code> </code>
  
-would leave the variable it was called with unchanged not set to 96.+</WRAP> 
 + 
 + 
 +---- 
 + 
 +==== Passing a parameter to a function by reference ====
  
-The addition of an **&** to the parameter name in C++ (which was a very confusing choice of symbol because an ‘&’ in front of variables elsewhere in C generates pointers!) causes the actual variable itself, rather than a copy, to be used as the parameter in the subroutine and therefore can be written to thereby passing data back out the subroutine. Therefore:+The addition of an **&** to the parameter name in C++ (which was a very confusing choice of symbol because an ‘&’ in front of variables elsewhere in C generates pointers!) causes the actual variable itself, rather than a copy, to be used as the parameter in the subroutine and therefore can be written to thereby passing data back out the subroutine. 
  
 <code cpp> <code cpp>
Line 137: Line 148:
 } }
 </code> </code>
- 
-would set the variable it was called with to 96. 
  
 <WRAP info> <WRAP info>
-**NOTE:**  This method of passing a variable as itself rather than a copy is called a **reference** in C++. +**NOTE:**  This would set the variable it was called with to 96.
- +
-To pass an alterable variable in original C, a rather involved method was used. +
- +
-  * This involved using a pointer to the variable as the parameter then altering what it pointed to was used. For example+
  
 +  * To pass an alterable variable in original C, a rather involved method was used.
 +  * This involved using a pointer to the variable as the parameter then altering what it pointed to was used.
 +  * This works but requires the every use of the variable in the called routine altered like that and the calling routine also altered to pass a pointer to the variable.
 +  * It is rather cumbersome.  For example:
 <code cpp> <code cpp>
 void Subroutine4(int *Parameter1) void Subroutine4(int *Parameter1)
Line 153: Line 162:
 } }
 </code> </code>
- 
-works but requires the every use of the variable in the called routine altered like that and the calling routine also altered to pass a pointer to the variable. It is rather cumbersome. 
  
 </WRAP> </WRAP>
Line 187: Line 194:
  
   * This is messy because it is essentially making an in-only variable passing method from a both-ways variable passing method which was itself made from an in-only variable passing method just to trick the compiler into doing some optimization.   * This is messy because it is essentially making an in-only variable passing method from a both-ways variable passing method which was itself made from an in-only variable passing method just to trick the compiler into doing some optimization.
-  * Ideally, the programmer should not need control this detail of specifying exactly how variables are passed, just say which direction the information goes and leave the compiler to optimize it automatically, but C was designed for raw low-level programming on far less powerful computers than are standard these days so the programmer has to do it explicitly.+  * Ideally, the programmer should not need to control this detail of specifying exactly how variables are passed, just say which direction the information goes and leave the compiler to optimize it automatically, but C was designed for raw low-level programming on far less powerful computers than are standard these days so the programmer has to do it explicitly.
  
 ---- ----
Line 226: Line 233:
 </code> </code>
  
-  * which will ban Method1 in Class2 from being anything which can attempt to alter any member variables in the object.+  * which will ban Method1 in Class2 from doing anything which can attempt to alter any member variables in the object.
  
 Of course one sometimes needs to combine some of these different uses of ‘const’ which can get confusing as in: Of course one sometimes needs to combine some of these different uses of ‘const’ which can get confusing as in:
Line 262: Line 269:
 http://duramecho.com/ComputerInformation/WhyHowCppConst.html http://duramecho.com/ComputerInformation/WhyHowCppConst.html
  
 +https://www.cprogramming.com/tutorial/const_correctness.html
c/c_const_declaration.1633379618.txt.gz · Last modified: 2021/10/04 20:33 by peter
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki