Submit Programming Language Questions

Home

Submit Programming Languages Questions

Technology Update

Knowledge Base

C Language Questions

What is wrong with this initialization:

   char *p = malloc(10);

   struct x1 { ... };
   typedef struct { ... } x2;

The second declaration is a slightly more abstract type; its users do not necessarily know that it is a structure, and the keyword struct is not used when declaring instances of it.

• A simple byte-by-byte comparison would have problems on random bits present in unused "holes" in the structure.
• A field-by-field comparison might require unacceptable amounts of repetitive code for large structures.

In order to compare two structures, it will be necessary to write a function, field by field, to do so.

   int a = 1000, b = 1000;
   long int c = a * b;

An explicit cast can be used to force long arithmetic:

   long int c = (long int)a * b;

It is possible to simulate pass by reference, by defining functions which accept pointers and then using the & operator when calling. The compiler will essentially provide the simulation when an array is passed to a function by passing a pointer instead.

After executing:

   #include <stdlib.h>
   int *dynarray;
   dynarray = malloc(10 * sizeof(int));

and if the call to malloc succeeds, a reference can be made to dynarray[i] (for i from 0 to 9) as if dynarray were a conventional, statically-allocated array (int a[10]).
 

The difference is that sizeof will not give the size of the "array".

Are there any free C compilers?

C++ Questions

We are uncertain as to whether our organization's compiler supports ANSI-C++?  

Experience with another programming language is not a prerequisite for learning C++.  As a result of the extensive use of special characters - {}[]*&!|..., code written in C++ gives the appearance of being more cryptic than some other languages. However, professional training will demonstrate that C++ is quite reasonable in its use of expressions and can be equally if not more straightforward than languages which rely on English words.

Example:

This code fragment uses the bool type, namespaces, and templates.

#include <iostream>

using namespace std;

template <class T>

bool ansisupported (T x) { return true; }

int main() {

  if (ansisupported(0)) cout << "ANSI OK";

  return 0;

}

If the compiler is able to compile this program, then it will be able to compile most of the existing ANSI-C++ code.

What is an inline function?

When the compiler inline-expands a function call, the function's code gets inserted into the caller's code stream. This is similar to what happens with a #define macro. 

There are several ways to designate that a function is inline, some of which involve the inline keyword.  No matter how a function is designated as inline, it is a request that the compiler is allowed to ignore.  The compiler might inline-expand some, all, or none of the calls to an inline function. This flexibility allows the compiler to treat large functions differently from small ones.  It also allows the compiler to generate code that is easier to debug; this assumes that the appropriate compiler options have been selected.

Do inline functions improve performance?

Explanation

There are a significant number of considerations which will impact the degree of optimization, if any, in called code.

Why inline functions might make code faster.

• Procedural integration might remove unnecessary instructions, which can result in a more expedient execution of code.

Why inline functions might make the code more concise and smaller.

• The compiler often generates more code to push/pop registers/parameters than it would by an inline-expansion of the function's body. This typically occurs with a very small function. 

• It also happens with large functions when the optimizer is able to remove redundant code through procedural integration.  This is when the optimizer might be able to make the large function smaller.

Why inline functions might decrease the number of cache misses.

• Inlining usually improves locality of reference within the binary code, which might decrease the number of cache lines needed to store the code of an inner loop. This ultimately could cause a CPU-bound application to run faster.

Why inline functions might prevent thrashing.

• The number of pages that need to be in memory at once might go down even if the executable size goes up.

Why inline functions might make the code slower.

• When there is too much inlining of functions, this may result in code bloat, which may in turn cause thrashing on demand-paged virtual-memory systems.

• Inlining functions might increase the size of the binary executable, and inline functions might cause thrashing.

Why inline functions might increase the number of cache misses.

• Inlining might cause an inner loop to span across multiple lines of the memory cache, and that might cause thrashing of the memory-cache.

Why inline functions might be irrelevant to speed.

• Most systems are not CPU-bound; rather they are I/O-bound, database-bound or network-bound.  The bottleneck in the system's overall performance will be the file system, the database or the network.

• Unless a CPU utilization is at at or near 100%, inline functions probably will not make a system faster.

There are no general rules which will yield an optimal unambiguous positive result. The use of inline functions might make the code faster, it might make it slower. The executable larger can be larger or smaller.

It might cause thrashing; it may prevent thrashing. Inline functions can have an unpredictable impact or be irrelevant in terms of speed.

Explanation by Example

Assume that List is the name of some class.

The function f() declares a local List object called x.

  void f()

 {

   List x;     // Local object named x (of class List)

   ...

 }

However, the function g() declares a function called x() that returns a List.

 void g()

 {

   List x();   // Function named x (that returns a List)

   ...

 }

Classes with static members are getting linker errors because static data members must be explicitly defined in one compilation unit. When this is not done, there in all likelihood will be an "undefined external" linker error.

Example:

 // Fred.h

  class Fred {

 public:

   ...

 private:

   static int j_;   // Declares static data member Fred::j_

   ...

 };

 The linker would state ("Fred::j_ is not defined") unless the definition has been made Fred::j_ in one of the source files.

Example:

 // Fred.cpp

 #include "Fred.h"

 int Fred::j_ = some_expression_evaluating_to_an_int;

 // Alternatively, if you wish to use the implicit 0 value for static ints:

 // int Fred::j_;

The usual place to define static data members of class Fred is file Fred.cpp or Fred.C or the  source file extension in use.

Self assignment is when someone assigns an object to itself.

Example:

#include "Fred.h"  // Defines class Fred

 void userCode(Fred& x)

 {

   x = x;           // Self-assignment

 }

This explicit self assignment is not practical; however, since more than one pointer or reference can point to the same object, which is known as aliasing, it is possible to have self assignment without knowing it.

 #include "Fred.h"  // Defines class Fred

  void userCode(Fred& x, Fred& y)

 {

   x = y;           // Could be self-assignment if &x == &y

 }

 int main()

 {

   Fred z;

   userCode(z, z);

   ...

 }

Easytrieve Plus

RECORD-LENGTH
RECORD-COUNT
FILE-STATUS
PATH-ID
IDMSCOM
SLC
SQLCA

A JOB, SORT, or SCREEN activity cannot be invoked in a JOB or SORT activity. EXECUTE statements in a SCREEN activity can invoke other activities; this is known as activity nesting.

PL/1 Questions

The advantages are:

1. Specifying the OPTIMIZE option will improve the speed of a program.

2. Choosing OPTIMIZE(2) directs the compiler to generate code for better performance.

• The resultant code typically will be shorter than when the program is compiled under NOOPTIMIZE.
• However, sometimes a longer sequence of instructions runs faster than a shorter sequence such as when a branch table is created for a SELECT statement where the values in the WHEN clauses contain gaps.  The increased number of instructions generated is usually offset by the execution of fewer instructions in other places.

3. Choosing OPTIMIZE(3) directs the compiler to generate even better code.

• However, the compilation will take longer than when specifying OPTIMIZE(2) and can be significantly longer.

A reasonable practice is to use PUT DATA statements in ON ERROR code.

on error begin;
          on error system;
          . . .
          put data;
          . . .
end;

The program would be further optimized by including a list of selected variables with the PUT DATA statement.

• A user-written function that computes a result based on unchanging data should be declared REDUCIBLE.
• A function that computes a result based on changing data, such as a random number or time of day, should be declared IRREDUCIBLE.

• Code that uses UNIONs instead of the DEFINED attribute is subject to less misinterpretation.
• Variable declarations in unions are in a single location making it easy to realize that when one member of the union changes, all of the others change also.
• The compiler will generate better code for union references.
• Dynamic change that use DEFINED variables are less obvious in declarations since the declare statements can be several lines apart.

The compiler does not treat NONASSIGNABLE scalar STATIC variables as true named constants.

The compiler generates better code whenever expressions are evaluated during compilation; therefore the use of named constants can be used to produce efficient code with no loss in readability.

For an event-based API, the parser reports events to the application through callbacks such as the start of the document, the beginning of an element, etc. The application provides handlers to deal with the events reported by the parser. The Simple API for XML or SAX is an industry-standard event-based API.

For a tree-based API, the parser translates the XML into an internal tree-based representation. Interfaces are provided to navigate the tree. IBM PL/I provides a SAX-like event-based interface for parsing XML documents. The parser invokes an application-supplied handler for parser events, passing references to the corresponding document fragments. The Document Object Model or DOM is a tree-based API.