HDTenEightyP/NetNews huggingface dataset:
From: shirleyk@qualix.com (Shirley Kumamoto)
Subject: Re: WANTED: SQL wrapper in _any_ OOL!
Followup-To: info@qualix.com
Summary: C++ for SQL
Keywords: C++ SQL databases
Reply-To: shirleyk@qualix.com
Organization: QUALiX Group, Inc.
Date: Tue, 8 Sep 1992 19:19:04 GMT

In article 460@rascal.UUCP, shu@rascal.UUCP (Shu) writes:
> 
> Hi!
> I posted this some time ago, but there was no answer :-(
> So, here is the re-post (slightly modified):
> 
>   We are currently developing an application (in C++) that needs to use data
>   base services. We decided to design a class that implements essentially
>   the standard SQL capabilities.
> 
>   Does anyone know anything about such classes already existing in any OO
>   language?
> 
>   We are interested in report writing as well.
> 
>   Thank you for _any_ ideas and references.
> 
> Please e-mail, I'll summarize (if I receive any answers, eh :-)
> 
> Cheers!
> Shu
> 
The Qualix Group has a product called db++ which is a C++ API to SQL and
ISAM databases.  Some of the key features are:

	* db++ gives you a C++ API for writing applications for commonly
	  used databases (like Oracle, Sybase, and many others)
	* db++ provides cross-platform portability. db++ is available on a wide
	 variety of platforms, including UNIX, DOS and OS/2 machines.


For more information contact:

Qualix Group
info@qualix.com
1900 S. Norfolk St. Suite 224
San Mateo, CA 
(415) 572-0200 (voice)
(415) 572-1300 (fax)


Newsgroups: comp.lang.c++
From: steve@taumet.com (Steve Clamage)
Subject: Re: defining cast operators outside classes
Organization: TauMetric Corporation
Date: Wed, 9 Sep 1992 16:15:13 GMT

tmb@arolla.idiap.ch (Thomas M. Breuel) writes:

|In article <1992Sep8.173613.25113@taumet.com> steve@taumet.com (Steve Clamage) writes:

|   tmb@arolla.idiap.ch (Thomas M. Breuel) writes:

|   >Apparently, it is impossible to define a conversion operator for a
|   >class without making the conversion operator a member function.

|   In the case of some operators you run the risk of having legal code
|   with different meanings depending on whether the operator declaration
|   is visible.

|Why is the C++ committee suddenly so concerned with my well-being?
|Those people who feel that such a feature is dangerous simply don't
|define conversion operators outside their classes.

This is not sudden, and not the action of the C++ committee.  The
rule is in the ARM, and predates the formation of the committee.
I was presenting a rationale for the rule, with which you are free
to disagree.

You are also free to submit a proposal to the C++ committee to change
the language in this regard.  Guidelines on how to create and submit
such a proposal have been published in various places.  You could also
join the committee and argue your viewpoints more directly.

-- 

Steve Clamage, TauMetric Corp, steve@taumet.com
Vice Chair, ANSI C++ Committee, X3J16
From: gordie@duts.ccc.amdahl.com (Gordie Freedman)
Newsgroups: comp.lang.c++
Subject: Re: Comma operator for stream I/O (was: Answer
Date: 15 Sep 92 22:22:35 GMT
Reply-To: gordie@duts.ccc.amdahl.com
Organization: Happy hacker bait and tackle shop

In article 4958@holden.lulea.trab.se, jbn@lulea.trab.se (Johan Bengtsson) writes:

>Since I am also in search of an example where the comma operator would be
>a good choice:
>
>Would the comma operator have been a good choice for stream I/O?
>I.e. instead of the rather hard-to-read expression
>
>  cout << "The value is " << value << endl;
>
>you would write
>
>  cout, "The value is", value, endl;
>
>The precedence is just right (very low).
>
>The comma operator could be used for input as well:
>
>  int i; float f; char c;
>  cin, i, f, c;
>

I'd rather see this:

cin >> i, f, c;
cout << "this is the value of i: ", i, endl ;

>--------------------------------------------------------------------------
>| Johan Bengtsson, Telia Research AB, Aurorum 6, S-951 75 Lulea, Sweden  |
>| Johan.Bengtsson@lulea.trab.se; Voice:(+46)92075471; Fax:(+46)92075490  |
>--------------------------------------------------------------------------



---
Gordie Freedman: gordie@kaleida.com Sigs are for kids


Newsgroups: comp.lang.c++
From: mdt@einoed.in-berlin.de (Michael Dietrich)
Subject: equal names
Summary: error with borlandc and equal names
Keywords: names borlandc 
Organization: Einoed Unix & Netzwerke, Berlin (FRG)
Distribution: comp
Date: Thu, 10 Sep 1992 18:11:57 GMT

i had problems with borlandc++ 3.0 in the following case:

class X {
	.
	.
};

class Y {
	Y(X*);
	void X(void );
};

Y::Y(X* pX)
//    ^ borlandc error: "missing '('"
{
}

void Y::X()
{
}

borlandc seems to have a problem with the memberfunction with the same name
as a class in the same scope.
other compilers had no problems with that code. for now i renamed X() but:
ist borlandc wrong or the other (zortech msc7) compilers?

please reply via email
Michael Dietrich, mdt@einoed.in-berlin.de
-- 
Michael Dietrich, mdt@einoed.in-berlin.de
Newsgroups: comp.lang.c++
From: gin503@cdc835.cdc.polimi.it (Maurizio Sartori Masar)
Subject: BC++ far new()
Date: Wed, 9 Sep 1992 13:39:02 GMT
Organization: C.d.C., Politecnico di Milano


From Borland C++ 3.00 Run Time Library :

/* filename - new.cpp */
void *operator new( size_t size );              //    use  malloc(size)

/* filename - newf.cpp */
void far * operator new( unsigned long size )   //  use  farmalloc(size)

/* filename - CS.LIB */
NEW             size = 83
        operator new(unsigned int)        set_new_handler(void(near*)())
        __new_handler
NEWF            size = 77
        operator new(unsigned long)



Question : how can I call the far version of 'new()' from a small memory
           program ?

Note: using long int doesn't work: 

		char far * p = new (char[10000L]);
	


					Maurizio


--
  ))    ))    ))      ))))))    ))    )))))))      Maurizio Sartori Masar
  ))))))))  ))  ))   ))))))   ))  ))  ))    ))   gin503@cdc835.cdc.polimi.it
  )) )) )) ))))))))       )) )))))))) ))))))       Politecnico di Milano
  ))    )) ))    ))  ))))))  ))    )) ))    ))            ITALY
From: rmartin@thor.Rational.COM (Bob Martin)
Newsgroups: comp.lang.c++
Subject: Re: Novice question
Date: 8 Sep 92 23:07:32 GMT

J.March@lut.ac.uk writes:

|Why dosn't this work?...

|class thing 
|{
|	...
|	void	f();
|	void	g();
|}

|void main()
|{
|	thing obj;

|	obj.f().g();
|}


This can be rewritten as  ( obj.f() ).g();

The return value of (obj.f()) is void.  So you are trying to invoke the g() member function of a 'void'.  This is a non-sequitur.




--
Robert Martin                        Training courses offered in:
R. C. M. Consulting                       Object Oriented Analysis
2080 Cranbrook Rd.                        Object Oriented Design
Green Oaks, Il 60048 (708) 918-1004       C++
Newsgroups: comp.lang.c++
From: dave@csis.dit.csiro.au (David Campbell)
Subject: C++ gdb
Organization: CSIRO Division of Information Technology
Date: Fri, 11 Sep 1992 04:44:50 GMT

Hi,

Does anyboyd have a port of the GNU debugger (gdb) that works with
AT&T C++'s mangling scheme?

We here are sick to death of Sun's dbx symbolic debugger.

After we have waited 20 mins for dbx to read in the symbols from our
executable, it prints out incorrect values for variables and generally
stuffs up.

Having taken a look at gdb it seems to be far better and will give us
large time savings if we can find one that will perform demangling.

Thanks,
Dave Campbell
dave@csis.dit.csiro.au
-- 
  +--------------------------------------------------+-----------------------+
  | Dave Campbell                                    |            UNIX & C++ |
  | Phone: + 61 6 275 0944      Fax: + 61 6 257 1052 |   _--_|\       PLEASE |
  | CSIRO Division of Information Technology         |  /      \             |
From: ssimmons@convex.com (Steve Simmons)
Newsgroups: comp.lang.c++
Subject: >>>>>> Novice Question on Wierd class definition
Date: 10 Sep 92 17:00:52 GMT
Organization: Engineering, CONVEX Computer Corp., Richardson, Tx., USA
X-Disclaimer: This message was written by a user at CONVEX Computer
              Corp. The opinions expressed are those of the user and
              not necessarily those of CONVEX.


> I have been looking at a piece of code that looks something like  
> this:
>
> class A {
> .. some defs...
> }
>
> class B(type) {
>        type** C;
> .more defs...
> }
> 
> Is B a template class, or what its it? Is it an anachronism?

It is a template class... Templates are available with ATT V3.0... 

Templates are useful when you have several structures that are similar
in structure; however, a common field of the structure differs among them.  

Thank you. 

						Steve Simmons
From: KOCHER@141.58.123.1 (HARTMUT KOCHER)
Subject: Booch notation in PC CASE tools
Organization: University of Stuttgart, IND
Date: Mon, 7 Sep 1992 07:54:38 GMT
X-News-Reader: VMS NEWS 1.20

In the product news section of the latest "C++ Report" I found 
two PC-based CASE tools that support the Booch notation. 
The first company mentioned is Popkin Software and Systems 
Inc. and their product is called "System Architect". The second 
product is "Object System/Designer" from Palladio Software.
Can someone provide the addresses, fax numbers, or email 
addresses of the companies?
Has anyone any experience with those products he'd like to 
share or can someone provide more information? Which one 
would you prefer?

I'd appreciate any help.

Hartmut Kocher
Kocher@nvdv.e-technik.uni-stuttgart.dbp.de
From: sg3235@sw1sta.uucp (Stephen Gevers)
Newsgroups: comp.lang.c++
Subject: Re: Answers on a postcard...
Date: 14 Sep 92 13:25:31 GMT
Organization: Southwestern Bell

In article <92255.112151KKEYTE@ESOC.BITNET> KKEYTE@ESOC.BITNET (Karl Keyte) writes:
]In article <1992Sep10.174914.838@taumet.com>, steve@taumet.com (Steve Clamage)
]says:
]>
]>Karl Keyte <KKEYTE@ESOC.BITNET> writes:
]>
]>|#include <iostream.h>
]>
]>|class X {
]>|   private:    int           value;
]>|   public:     int           operator , (int i) { return i+10; };
]>|               int           operator + (int i) { return value+i; };
]>|               X &           operator = (int i) { value=i; return *this; };
]>|};
]>
]>
]>|void main()
]>|{
]>|   X         x;
]>
]>|   cout << "Value is " << (x=1, x+1) << endl;
]>|}
]>
]>In the expression in parens, it is unspecified whether "x=1" or
]>"x+1" is evaluated first.  They are arguments to the "operator,()"
]>function, not the left and right side of a comma-expression.  If
]>"x+1" is evaluated first, which is legal, it will use an
]>uninitialized "x.value".
]>
]>Don't write code which depends on unspecified order of evaluation.
]>
]>If there were no "op,()", the "," would mark a comma-expression,
]>and the "x=1" would have to be evaluated first; in that case the
]>whole expression would be well-defined.
]
]The implication of what you say is that it is not possible to overload
]operators maintaining the correct functionality of the operator.  This
]indeed means that precedence in overloaded operators cannot be maintained
]if all operands are simply passed as arguments to the function implementing
]the operator functionality and evaluated in a language independent order.
]Imagine commonly used "chain" operators such as && and ::.
]
]If what is described above is correct, and Mr.Clamage clearly has much
]experience in the area, then I think we have justification for pressing
]for a change in this area.  If not, I would ask: How does one overload
]the comma operator while maintaining its attibutes as an operator?
]
]Karl

While I understand Mr. Clamage's explanation, I do not see any support of it
in the ARM.  Specifically, section 5.18 states "A pair of expressions separated
by a comma is evaluated left-to-right and the value of the left expression is
discarded.  All side effects of the left expression are performed before the 
evaluation of the right expression."  Section 5 states "Operator overloading
cannot modify the rules for operators applied to types for which they are
defined by the language itself."  Finally, the commentary in section 13.4 says
"In particular, overloaded operators , and ->* obey exactly the same rules as
other overloaded binary operators, such as ^ and %."

I have the 1st edition of the ARM and I don't know if there is any more
specific reference to the comma operator in the second edition.  I tested the
above code on Borland C++ 3.0 and Cfront 2.0.  Borland gave a result in the
high 6000's and Cfront gave the result of 12.  BTW, has anyone really used the
comma operator for something useful???

Stephen Gevers
sw1sta.sbc.com
Newsgroups: comp.lang.c++
From: karel@cv.ruu.nl (Karel Zuiderveld)
Subject: Ellemtel Rules and recommendations
Summary: ftp site?
Date: Sat, 12 Sep 1992 14:00:30 GMT
Organization: University of Utrecht, 3D Computer Vision Research Group

Where can I ftp a copy of "Programming in C++ - Rules and
Recommendation" written by Mats Henricson and Erik Nyquist of Ellemtel
Telecommunications Systems Laboratories?

I have lost the original postscript file.

karel

-- 
Karel Zuiderveld                            E-mail: karel@cv.ruu.nl
3D Computer Vision - Room E.02.222          Tel:    (31-30) 506682/507772
Academisch Ziekenhuis Utrecht               Fax:    (31-30) 513399
Heidelberglaan 100, 3584 CX Utrecht, The Netherlands
Newsgroups: comp.lang.c++
From: kanze@us-es.sel.de (James Kanze)
Subject: Re: GOTO, was: Tiny proposal for na
Organization: SEL
	<1992Aug26.130335.26725@hemlock.cray.com> <1992Aug26.194538.1598@spss.com>
	<rmartin.714931485@thor> <1992Aug27.181013.29933@spss.com>
	<rmartin.715102882@thor> <1992Aug31.170908.13389@us-es.sel.de>
	<23634@alice.att.com>
Date: 9 Sep 92 20:36:33

In article <23634@alice.att.com> ark@alice.att.com (Andrew Koenig) writes:

> But since every program can be mechanically rewritten in that form,
> it doesn't matter.  Moreover, if we do grant your premise, we might
> argue that it is even easier to prove programs correct if we eliminate
> iteration, which after all can always be expressed by recursion.
> [Indeed, there is now a whole family of languages that do just that]

As you so well point out in the rest of your article, a proof is
really just a convincing argument.  What we want is to be able to
reason clearly about a piece of code.  This reasoning is simpler if
the code conforms to the standards of structured programming.  The
fact that the code could be mechanically rewritten to conform to these
standards is academic if this doesn't actually take place.

The costs and benefits must be balanced.  The balance may be different
according to the language and the application, but I would imagine
that the additional simplicity in reasoning about the program would
not make up for the loss of expressivity (in C/C++, at least) due to
not using iteration.  In the same way, it is possible that in certain
real time applications, the loss of performance due to not using goto
may actually outway the added complexity of the code analysis.  In
this case, I use a goto.  (Actually, if it gets this time critical, I
usually drop back into assembler.:-).

Overall, however, my experience is that some sort of (generally
informal) proof of correctness, based on the fundamental control flow
structures, is very cost-efficient.  Generally speaking, it costs less
to write a program correctly from the start, than to try and find out
why it doesn't work later.
--
James Kanze                         GABI Software, Sarl.
email: kanze@us-es.sel.de           8 rue du Faisan
                                    67000 Strasbourg
                                    France
Newsgroups: comp.lang.c++
From: pjl@sparc10.cs.uiuc.edu (Paul Lucas)
Subject: Re: Reference to a pointer??
Keywords: pointer, reference
Organization: University of Illinois at Urbana-Champaign
Distribution: usa
Date: Thu, 10 Sep 1992 22:35:28 GMT

In <ucosmo.716157377@mcl> ucosmo@mcl.ucsb.edu (Boris Burtin) writes:

>I have not been able to dig up any information on how to change a pointer 
>inside a function (aside from the good old dual-pointer C solution).  I know
>that, for example, an int can be changed in a function like so:

>void f(int& i)
>{
>	i = 0;
>}

>So why can't you do this:

>void f(int& *p)
>{
>	p = 0;
>}

>Or do I just have the syntax wrong?

*****>	You have the syntax wrong.  C(++) is sort of the "Hebrew" of
	computer languages with regard to declarations, i.e., it makes
	more sense if you read and write them from right to left.

		int &*p; // right-to-left: pointer to a reference to an int
			 // which is illegal since references are not
			 // first-class objects
		
		int *&p; // reference to a pointer to an int: legal
	
	This is mentioned on p.29 of my book.
-- 
	- Paul J. Lucas				University of Illinois	
	  AT&T Bell Laboratories		at Urbana-Champaign
	  Naperville, IL			pjl@cs.uiuc.edu
Newsgroups: comp.lang.c++
From: antony@ee.uts.edu.au (Antony Richards)
Subject: Name Mangling (replies)
Organization: University of Technology, Sydney, Australia
Date: Wed, 9 Sep 1992 06:25:59 GMT

Thankyou to all the resonses I received.  Here is a summary of the responses.

>From: jbuck@ohm.Berkeley.EDU (Joe Buck)
>There's a routine provided with gdb-4.6 that you could use.  Of course,
>it's GPL'ed, but if that's a problem for you (becuase you want to "hoard
>your code", as the gnu folks say), you could have one person
>determine the algorithm from the code and write a spec and have another
>person write new code from the spec.


>From: ENURMI@tnclus.tele.nokia.fi
>From: andy@spec0.electrical-engineering.manchester.ac.uk
>Why don't you grab the source to gcc then you can use the source code for
>the mangling?

I have it, but some simple grep's did not reveal anything.

>From: jamshid@emx.cc.utexas.edu (Jamshid Afshar)
>Name mangling is not standardized.  You'll have to ask each compiler
>vendor or in gnu.g++.help.

I have not doen this yet, because I worked out what I need at the moment,
by looking at the machine code output of the mangled label of a constructor
without any parameters.  These labels are:-
__<strlength(classNmae)><className>

I hope that this has been useful.

thanks,
antony.
From: Bruce.Hoult@bbs.actrix.gen.nz
Newsgroups: comp.lang.c++
Subject: Re: Need Help on trivial issue
Date: 13 Sep 92 14:06:19 GMT
Organization: Actrix Information Exchange

In article <14497@goanna.cs.rmit.oz.au> gtj@goanna.cs.rmit.oz.au (Glenn T Jayaputera) writes:
> Hi, I need help on the following program.  The problem I have is if I
> input the value > 1.1 the string "Yahooo....." is only printed once.
> I dont Understand why n==of only for a value of 0.5 not 1.0, 1.5, 2.0, etc.

The problem is that 0.1 isn't exactly represented in the binary system
-- it will actually be something like 0.00011001100110011...  This
means that when you add five of them together you will get something
that would look like 0.4999999 (in decimal) instead of 0.5.

The moral? *NEVER* expect the == comparison to work on floating point numbers.
-- 
Bruce.Hoult@bbs.actrix.gen.nz   Twisted pair: +64 4 477 2116
BIX: brucehoult                 Last Resort:  PO Box 4145 Wellington, NZ
"Cray's producing a 500 MIPS personal computer with 256MB RAM and 8 GB
hard disk that fits in your pocket!"   "Great!  Is it PC compatible?"
From: tmb@arolla.idiap.ch (Thomas M. Breuel)
Newsgroups: comp.lang.c++
Subject: Re: zero-length datatype
Date: 12 Sep 92 01:13:32 GMT
	<HAYDENS.92Sep9215705@bullwinkle.juliet.ll.mit.edu>
	<TMB.92Sep10120206@arolla.idiap.ch> <23650@alice.att.com>
Reply-To: tmb@idiap.ch
Distribution: comp
Organization: IDIAP (Institut Dalle Molle d'Intelligence Artificielle
	Perceptive)
In-reply-to: ark@alice.att.com's message of 10 Sep 92 17:36:24 GMT

In article <23650@alice.att.com> ark@alice.att.com (Andrew Koenig) writes:

   There is one problem with `void' as a true datatype that I have not
   been able to solve: ISO C says that

	   void f(void);

   is a function with no arguments at all and C++ therefore follows suit.
   Making void into a true type would therefore require some compatibility
   warts; it is not clear exactly what would be necessary or what effect it
   would have on the rest of the language.

I mentioned this in my posting; I don't think this is a serious
problem, for the following reasons.

To remain compatible with C, you can interpret the above prototype as
meaning either "a function taking no arguments" or as "a function
taking exactly one argument of type 'void'". That is, it would be
legal to call the above function as "f()" or "f(void())". Since there
is no actual data being passed and no actual dereferencing happening,
this is harmless.

Compiler writers might be encouraged to issue a warning when a
declaration of "void f(void);" occurs in the C++ language context
(rather than inside an 'extern "C"') _and_ the function is actually
being used without arguments. Likewise, using any kind of "void" type
cinside the C language context should be flagged as an error.

Maybe the interpretation of "void f(void)" as a function taking no
arguments could eventually be phased out in the C++ language context.
After all, K&R style declarations and definitions are also valid in
ISO C but not in C++.

					Thomas.
From: tmb@arolla.idiap.ch (Thomas M. Breuel)
Newsgroups: comp.lang.c++
Subject: backwards references in templates
Date: 7 Sep 92 20:37:20 GMT
Reply-To: tmb@idiap.ch
Distribution: comp
Organization: IDIAP (Institut Dalle Molle d'Intelligence Artificielle
	Perceptive)

The following definition of Foo appears to be illegal (GNU C++ doesn't
accept it, and the ARM doesn't seem to sanction it):

	template <class K,K x>
	struct Foo {
		K y;
		Foo() { y = x; }
	};
	
This restriction on the uses of template arguments (as in "Foo") is a
serious problem, since such dependencies occur frequently.

First, I'd like to know: are such template constructs indeed
prohibited by the language definition?

Second, I'd like to know what alternative paradigms there are.  The
only one that I can think of involves nested template classes
(inconvenient, doesn't work in any existing compiler). In some cases,
non-type template arguments like "x" can also be made (static) data
members, but that implies runtime space/time overhead, and the use of
static members requires a separate source file for initialization.
Are there any more satisfactory solutions?

					Thomas.
From: d9patrik@dtek.chalmers.se (Patrik Larking)
Newsgroups: comp.lang.c++
Subject: I/O streams in ANSI definition?
Date: 8 Sep 92 16:03:51 GMT
Organization: Chalmers University of Technology, Gothenburg Sweden

I have a few questions about to the c++ I/O streams.

Are they included in the ANSI definition of the c++ language?
Are they a part of the 3.0 definition or is there a separate definition?
Are binary files included (ios::binary)?
I currently own the C++ Primer by Lippman and The Annotaded reference manual.
Neither of theese treat the I/O stream fully and I don`t want to bye a complte
new book! 
 Are there any seperate publications witch only treat the I/O library.
Can I require the ANSI documents direct whole c++ definition or partly (I/O 
library only)?
How is this made?


/Patrik




Newsgroups: comp.lang.c++
From: nbhandar@enuxha.eas.asu.edu (Narendra Bhandari )
Subject: List of FAQ
Organization: Arizona State University, Tempe, AZ
Distribution: usa
Date: Tue, 15 Sep 1992 18:25:15 GMT


Please mail directly to me(Look at the Subject ).

--
|-^-^-^-^-^-----------Narendra Bhandari-------------------^-^-^-^-^	|
o  Internet nbhandar@enuxha.eas.asu.edu	   				o
|  950 S Terrace Rd ,#c243 Tempe AZ 85281	(602) 921-3401	    -	|
	GENIUS IS 99% PERSPIRATION , 1% INSPIRATION