helpme!.doc

hello everybody. good lucky to you

  
              Turbo C++: ANSWERS TO COMMON QUESTIONS 
  
  
 G e t t i n g     S t a r t e d 
 ---------------------------------------------------------------------- 
 Q. How do I install Turbo C++? 
 A. Run the INSTALL program from DISK 1. To start the installation, change 
    your current drive to the one that has the install program on it and 
    type INSTALL. You will be given instructions in a box at the bottom of 
    the screen for each prompt. For example, if you will be installing from 
    drive A:, type: 
  
       A: 
       INSTALL 
  
    At this point, the INSTALL program will appear with menu selections 
    and descriptions to guide you through the installation process. 
  
 Q. How do I run Turbo C++? 
 A. After you have installed Turbo C++, be sure to add the path to 
    the 'BIN' subdirectory of your TC++ installation (e.g., C:\TC\BIN) 
    to your DOS path. Now you can type "TC" at the DOS prompt and from any 
    directory and you're ready to go. 
  
 Q. What is a configuration file? 
 A. A configuration file tells Turbo C++ what options to default to 
    and where to look for its library and header files. TC.EXE looks 
    for a configuration file named TCCONFIG.TC, and TCC.EXE looks for 
    a file named TURBOC.CFG. 
  
 Q. How do I create a configuration file? 
 A. When you run the INSTALL program it creates a configuration 
    file named TURBOC.CFG for TCC.EXE. This file is just an 
    ASCII file, which you can change with any text editor. It 
    contains the path information for the library and header 
    files for TCC.EXE to use. The INSTALL program does not 
    create a TCCONFIG.TC file for TC.EXE because it installs the 
    directory information directly into TC.EXE. You can create a 
    configuration file for the IDE by running TC.EXE, 
    setting your options however you want to set them, and typing 
    Alt-O/S. 
  
 C o m m o n   C + +   Q u e s t i o n s 
 ---------------------------------------------------------- 
  
 Q. When linking C or Assembly language modules with C++ modules I get 
    undefined symbol errors at link time.  It appears that none of the C 
    or Assembly public symbols can be found. 
 A. C++ is a strongly typed language.  In order to support the language 
    to its fullest, Turbo C++ must attach information to the symbols 
    generated for function names and variables.  When this is done, the 
    symbol will no longer match the standard C style function name.  In 
    order to link correctly, the compiler must be notified that the symbol 
    is declared in an external module without type information tacked on 
    to the symbol.  This is done by prototyping the function as type 
    extern "C".   Here is a quick example: 
       extern "C" int normal_c_func( float, int, char );  // name not altered 
       void cplusplus_function( int );  // name altered 
    See related comments under Linker Errors and in the Paradox Engine 
    question in this section.  
  
 Q. Classes with static data members are getting linker errors ("undefined"). 
 A. This code is built into Turbo C++ 1.0 but not in version 3.0. 
    In the 1.0 compiler, static members without definitions were given a 
    default value of 0.  This default definition will no longer be made in the 
    compiler.  The programmer must now give an explicit definition for each 
    static member.  Here is a quick example: 
       class A 
       { 
          static int i; 
       }; 
    A linker error saying that A::i is not defined will result unless the 
    source also contains a line such as: 
       int A::i = 1; 
  
 Q. What potential problems can arise from typecasting a base class pointer 
    into a derived class pointer so that the derived class's member functions 
    can be called? 
 A. Syntactically this is allowable. There is always the possibility of 
    a base pointer actually pointing to a base class. If this is 
    typecast to a derived type, the method being called may not exist 
    in the base class. Therefore, you would be grabbing the address of 
    a function that does not exist. 
  
 Q: What's the difference between the keywords STRUCT and CLASS? 
 A: The members of a STRUCT are PUBLIC by default, while in CLASS, 
    they default to PRIVATE. They are otherwise functionally equivalent. 
  
 Q: I have declared a derived class from a base class, but I can't access any 
    of the base class members with the derived class function. 
 A: Derived classes DO NOT get access to private members of a base class. 
    In order to access members of a base class, the base class members must 
    be declared as either public or protected. If they are public, then 
    any portion of the program can access them. If they are protected, they 
    are accessible by the class members, friends, and any derived classes. 
  
 Q: How can I use the Paradox Engine 1.0 with C++?, 
 A: Because the Paradox Engine functions are all compiled as C functions, 
    you will have to assure that the names of the functions do not get 
    "mangled" by the C++ compiler. To do this you need to prototype the 
    Engine functions as extern "C". In the pxengine.h header file insert 
    the following code at the lines indicated. 
  
       /* inserted at line # 268 */ 
       #ifdef __cplusplus 
       extern "C" { 
       #endif 
  
       /* inserted at line # 732, just before the final #endif */ 
       #ifdef __cplusplus 
       } 
       #endif 
  
    Paradox Engine version 2.0 is "aware" of C++ and thus does not require 
    any modifications to its header file. 
  
 Q: I have a class that is derived from three base classes. Can I insure that 
    one base class constructor will be called before all other constructors? 
 A: If you declare the base class as a virtual base class, its constructor 
    will be called before any non-virtual base class constructors. Otherwise 
    the constructors are called in left-to-right order on the declaration 
    line for the class. 
    
 Q: Are the standard library I/O functions still available for use with 
    the C++ iostreams library? 
 A: Yes, using 
  
       #include <stdio.h> 
  
    functions such as printf() and scanf() will continue to be 
    available. However, using them in conjunction with stream oriented 
    functions can lead to unpredictable behaviour. 
  
 Q. In C++, given two variables of the same name, one local and one global, 
    how do I access the global instance within the local scope? 
 A. Use the scope (::) operator. 
  
       int x = 10; 
       for(int x=0; x < ::x; x++) 
       { 
           cout << "Loop # " << x << "\n"; // This will loop 10 times 
       } 
  
 Q. Will the following two functions be overloaded by the compiler, or 
    will the compiler flag it as an error? Why? 
        void test( int x, double y);  &  int test( int a, double b); 
 A. The compiler will flag this as a redeclaration error because 
    neither return types nor argument names are considered when determining 
    unique signatures for overloading functions. Only number and type 
    of arguments are considered. 
  
 Q. If I pass a character to a function which only accepts an int, 
    what will the compiler do? Will it flag it as an error? 
 A. No. The compiler will promote the char to an int and use the integer 
    representation in the function instead of the character itself. 
  
 Q. I was trying to allocate an array of function pointers using the new 
    operator but I keep getting declaration syntax errors using the following 
    syntax:  new int(*[10])();   What's wrong? 
 A. The new operator is a unary operator and binds first to the int keyword 
    producing the following:  (new int) (*[10])(); 
    You need to put parentheses around the expression to produce the 
    expected results:  new (int (*[10]()); 
  
 Q. What are inline functions? What are their advantages? How are they 
    declared? 
 A. An inline function is a function which gets textually inserted by 
    the compiler, much like macros. The advantage is that execution time 
    is shortened because linker overhead is minimized. They are declared 
    by using the inline keyword when the function is declared: 
  
       inline void func(void) { cout << "printing inline function \n"; } 
  
    or by including the function declaration and code body within a class: 
  
       class test 
       { 
       public: 
       void func(void) { cout << "inline function within a class.\n"} 
       }; 
  
 Q. If I don't specify either public or private sections in a class, 
    what is the default? 
 A. In a class, all members are private by default if neither public nor 
    private sections are declared. 
  
 Q. What does the _seg modifier do? 
 A. Using _seg causes a pointer to become a storage place for a 
    segment value, rather than an offset ( or a segment/offset ). 
    For instance, if "int _seg *x" contains the value 0x40, 
    then when you use "*x", the value pointed to will be at 
    segment 0x40, offset 0. If you add a value to the pointer, 
    the value is multiplied by the size of the pointer type. That 
    new value is used as an offset, and is combined with the segment 
    value contained in the pointer. For instance, 
  
       int _seg *x; 
       int value; 
  
       x = (int _seg *)0x40; 
       value = *(x + 20); 
  
    value is assigned the value of the integer at 0x40:0x28 
    (Remember, 20 * sizeof(int) = 40 = 0x28). 
  
  
 Q. Can I statically allocate more than 64K of data in a single module? 
 A. Yes. Far data items are now supported: 
  
       ... 
       char far array1[60000L]; 
       char far array2[60000L]; 
       ... 
  
    For arrays larger than 64k use: 
  
       char huge array3[100000L]; 
  
 Q. What is a friend member function? 
 A. Declaring a friend gives non-members of a class access to the 
    non-public members of a class. 
  
 Q. Why do I get a "Type name expected" error on my definition of a 
    friend class in my new class? 
 A  You need to let the compiler know that the label you use for your 
    friend class is another class. If you do not want to define your 
    entire class, you can simply have "class xxx", where xxx is your 
    label. 
  
 Q: How can I output hex values in upper case using the iostream libraries? 
 A: You need to set the state of the stream using setf(). For example, 
  
       #include <iostream.h> 
  
       int main(void) 
       { 
          cout << hex; 
          cout << "\nNot upper-case : " << 255; 
          cout.setf(ios::upper-case); 
          cout << "\nUppercase     : " << 255; 
          return 0; 
        } 
  
 Q. What is the "this" pointer? 
 A. "this" is a local variable in the body of a non-static member function. 
    It is a pointer to the object for which the function was invoked. It 
    cannot be used outside of a class member function body. 
  
 Q. Why does a binary member function only accept a single argument? 
 A. The first argument is defined implicitly. 
  
 Q. Looking through the class libraries there are definitions in classes 
    which look like: 
       class test { 
           int funct( void ) const; 
       }; 
    What is the const keyword doing here? 
 A. There is a pointer to the object for which a function is called 
    known as the 'this' pointer.  By default the type of 'this' 
    is  X *const ( a constant pointer).  The const keyword changes the 
    type to const X *const ( a constant pointer to constant data ). 
  
 Q: I want to use _new_handler and set_new_handler. 
 A: Turbo C++ supports _new_handler and set_new_handler. The type of 
    _new_handler is as follows. 
        typedef void (*vfp)(void); 
        vfp _new_handler; 
        vfp set_new_handler( vfp ); 
  
 Q: I would like to use C++ fstreams on a file opened in binary mode, 
    how is this done?