Chinaunix

标题: c与c++区别讨论 [打印本页]

作者: 无双 时间: 2003-06-21 18:26
标题: c与c++区别讨论
讨论这个只是为了以后设计程序时应该怎样思考, 怎样能得到更好更快的设计
欢迎各位发言

从设计模式的角度来讲
c是面向过程的,
c++是面向对象的, 这应该是最主要的区别了

c因为数据与算法分开
所以想用来写面向对象的程序不是很好
我认为

各位发表一下高见

作者: JohnBull 时间: 2003-06-21 18:44
标题: c与c++区别讨论
我觉得c++是对c的一个对象化封装.目的是为了便于软件的大规模生产.

作者: 大菠萝 时间: 2003-06-21 18:58
标题: c与c++区别讨论
我觉得C++不是一个C的扩展，而是一门崭新的语言，只是基本的语法和C相同，在C语言世界中，可能可以将
class A
{
public:
int member1,member2;
private:
int  member3;
public:
void Function1();
}

用
struct A
{
int member1;
int  member2;
int  member3;
}
void A_Function1()
{
}
来代替，但是不可能在C语言世界中实现设计模式中模式，换一句话说，就是不好
在C语言世界中搭建一个好的程序结构（我说的是不好建，但是外国的那些牛人除外）。

作者: icedust 时间: 2003-06-21 19:07
标题: c与c++区别讨论
我说的是不好建，但是外国的那些牛人除外

---------foreign strong is too strong to achieve

作者: 无双 时间: 2003-06-21 19:16
标题: c与c++区别讨论
先说说两个的概念
如果你使用c++但是不会面向对象那么应该补课了
因为c++的精髓正是支持面向对象

也谈面向对象 //从网上转的,http://www.zdnet.com.cn/developer/tech/story/0,2000081602,39052846,00.htm，更多请看那里

我们经常所说的“对象”，一班指的是解决信息领域内所遇到问题的方法。特别是应用软件技术来解决问题的方法。如我们经常碰到的面向对象的编程（Object-Oriented Programming）、面向对象的分析（Object-Oriented Analysis）、面向对象的设计（Object-Oriented Design）等。应用前面所介绍的关于对象的概念，可以对这些问题做进一步的分析。在面对较复杂的系统，我们可以将它作为一个对象来进行分析。一个系统（解决某个问题的全套解决方案）作为一个对象，可以由多个部分组成。同样，这个对象也可以由多个对象组成。对于同类的事物，可以由一个对象来表示。这样做的益处是显而易见的，它灵活而高效，可以大大减轻设计人员的工作量，简化实际的模型。举一个例子。在关系型数据库的设计当中，我们可以把一个元组当作对象，给它定义一组操作方法。这些方法将适用于所有元组，从而我们不必在更大的范围内去细致的考虑不同的元组（如判断一个元素是否合法）：因为它们有一组公共的面向本身的方法，它们“自己”可以“解决”自己的问题。更上一层的对象可以是一个表、视图等。表对象在元组对象的基础上又有它们自己的方法，如增加、删除等。从这个层面上讲，它也只需要做“自己”的事情，因为有元组对象的支持，它无须去考虑像元素是否合法这类的事情。甚至，有时为了满足我们还可以将元素或表群当作时对象并定义它们自己的方法。这样，更能显示面向对象的优势。

面向过程是针对事件发展的过程编程

面向对象是以对象为导向指导设计,c++中的类封装与多态有利于对象的实现
面向过程是以过程为导向指导设计

这是我的理解
各位

作者: 大菠萝 时间: 2003-06-21 19:22
标题: c与c++区别讨论
跟大家推荐一个外国牛人写的程序，在
http://www.cs.ucr.edu/~marioh/spatialindex/
非常好，Java式的结构 + C语言的强大

作者: 无双 时间: 2003-06-21 19:27
标题: c与c++区别讨论
大家回答的都不错,继续

我觉得C++更适合大软件开发

因为一个复杂系统有很多过程
每个过程又相互关联

如果使用面向过程的话,除非知道整个系统的框架以及需求
不然还是很难定义好接口的
这时可能的做法是把系统分成多个模块, 每个模块是内部紧关联模块间松耦合的
把改动尽量限制在模块内.但如果开始模块分的不好或是需求的改变使系统模块那么代码可能就要重写,这样工作量会很大

但是面向对象则不然
可以把系统分成多个对象,每个对象定义好自己接口, 但是具体实现不定义
这样在需求变化时只要修改某个类自己的实现就可以了
不用全部修改接口
如果需求改变, 改么类还可以重用,类是比模块小的单元, 改运量很小

C因为数据与算法分开
所以想用面向对象的设计,我觉得很难
如果使用C，那么程序的最小单元只能是模块而不可能做到像C++的类

如果有人认为可以在c中使用面向对象
那么请介绍方法,我也想了解一下

作者: JohnBull 时间: 2003-06-21 19:56
标题: c与c++区别讨论

原帖由 "大菠萝" 发表：
我觉得C++不是一个C的扩展，而是一门崭新的语言，只是基本的语法和C相同，在C语言世界中，可能可以将
class A
{
public:
int member1,member2;
private:
int member3;
public:
void Function1();
}

用
..........

是"封装",连"扩展"都算不上,因为从底层来看,C++没有引入任何新的东西(这也就是C++不如java的原因).
在相当长的一段时间里,C++编译实际上就是先把C++转化成C,然后用C编译器生成代码的.
C++是一个从C时代向OOP时代过渡的一个语言.如果我决定学习OOP,肯定从java甚至Python入手,

作者: 无双 时间: 2003-06-21 20:01
标题: c与c++区别讨论
底层的东西不用管

看上层就行了
因为底层都是编译实现的
我们如果想用C实现多态和继承
有了类和多态
就可以认为是OO了

作者: 大菠萝 时间: 2003-06-21 20:10
标题: c与c++区别讨论
不要把C++说的这么差，下面是一个线层池的实现，用C++写的，如果你来写，你如何写？

#ifndef THREAD_POOL__HPP
#define THREAD_POOL__HPP
/* $Id: thread_pool.hpp,v 1.10 2003/02/26 21:34:06 gouriano Exp $
* ===========================================================================
*
* PUBLIC DOMAIN NOTICE
* National Center for Biotechnology Information
*
* This software/database is a "United States Government Work" under the
* terms of the United States Copyright Act. It was written as part of
* the author's official duties as a United States Government employee and
* thus cannot be copyrighted. This software/database is freely available
* to the public for use. The National Library of Medicine and the U.S.
* Government have not placed any restriction on its use or reproduction.
*
* Although all reasonable efforts have been taken to ensure the accuracy
* and reliability of the software and data, the NLM and the U.S.
* Government do not and cannot warrant the performance or results that
* may be obtained by using this software or data. The NLM and the U.S.
* Government disclaim all warranties, express or implied, including
* warranties of performance, merchantability or fitness for any particular
* purpose.
*
* Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Aaron Ucko
*
* File Description:
* Pools of generic request-handling threads.
*
* TEMPLATES:
* CBlockingQueue<>; -- queue of requests, with efficiently blocking Get()
* CThreadInPool<>; -- abstract request-handling thread
* CPoolOfThreads<>; -- abstract pool of threads sharing a request queue
*
* SPECIALIZATIONS:
* CStdRequest -- abstract request type
* CStdThreadInPool -- thread handling CStdRequest
* CStdPoolOfThreads -- pool of threads handling CStdRequest
*/
#include <corelib/ncbistd.hpp>;
#include <corelib/ncbithr.hpp>;
#include <corelib/ncbi_limits.hpp>;
#include <util/util_exception.hpp>;
#include <deque>;
BEGIN_NCBI_SCOPE
/////////////////////////////////////////////////////////////////////////////
//
// TEMPLATES:
//
// CBlockingQueue<>; -- queue of requests, with efficiently blocking Get()
// CThreadInPool<>; -- abstract request-handling thread
// CPoolOfThreads<>; -- abstract pool of threads sharing a request queue
//
template <typename TRequest>;
class CBlockingQueue
{
public:
CBlockingQueue(unsigned int max_size = kMax_UInt)
: m_GetSem(0,1), m_PutSem(1,1), m_MaxSize(max_size) {}
void Put(const TRequest& data); // Throws exception if full
void WaitForRoom(unsigned int timeout_sec = kMax_UInt,
unsigned int timeout_nsec = kMax_UInt) const;
// Blocks politely if empty
TRequest Get(unsigned int timeout_sec = kMax_UInt,
unsigned int timeout_nsec = kMax_UInt);
unsigned int GetSize(void) const;
unsigned int GetMaxSize(void) const { return m_MaxSize; }
bool IsEmpty(void) const { return GetSize() == 0; }
bool IsFull(void) const { return GetSize() == GetMaxSize(); }
protected:
// Derived classes should take care to use these members properly.
volatile deque<TRequest>; m_Queue;
CSemaphore m_GetSem; // Raised iff the queue contains data
mutable CSemaphore m_PutSem; // Raised iff the queue has room
mutable CMutex m_Mutex; // Guards access to queue
private:
unsigned int m_MaxSize;
};
// Forward declaration
template <typename TRequest>; class CPoolOfThreads;
template <typename TRequest>;
/* abstract */ class CThreadInPool : public CThread
{
public:
typedef CPoolOfThreads<TRequest>; TPool;
CThreadInPool(TPool* pool) : m_Pool(pool) {}
protected:
virtual ~CThreadInPool(void) {}
virtual void Init(void) {} // called at beginning of Main()
// Called from Main() for each request this thread handles
virtual void ProcessRequest(const TRequest& req) = 0;
virtual void x_OnExit(void) {} // called by OnExit()
private:
// to prevent overriding; inherited from CThread
virtual void* Main(void);
virtual void OnExit(void);
TPool* m_Pool;
};
template <typename TRequest>;
/* abstract */ class CPoolOfThreads
{
public:
friend class CThreadInPool<TRequest>;;
typedef CThreadInPool<TRequest>; TThread;
CPoolOfThreads(unsigned int max_threads, unsigned int queue_size,
int spawn_threshold = 1)
: m_ThreadCount(0), m_MaxThreads(max_threads),
m_Delta(0), m_Threshold(spawn_threshold), m_Queue(queue_size)
{}
virtual ~CPoolOfThreads(void) {}
void Spawn(unsigned int num_threads);
void AcceptRequest(const TRequest& req);
void WaitForRoom(void) { m_Queue.WaitForRoom(); }
bool IsFull(void) const { return m_Queue.IsFull(); }
protected:
virtual TThread* NewThread(void) = 0;
volatile unsigned int m_ThreadCount;
volatile unsigned int m_MaxThreads;
volatile int m_Delta; // # unfinished requests - # threads
int m_Threshold; // for delta
CMutex m_Mutex; // for volatile counters
CBlockingQueue<TRequest>; m_Queue;
};
/////////////////////////////////////////////////////////////////////////////
//
// SPECIALIZATIONS:
//
// CStdRequest -- abstract request type
// CStdThreadInPool -- thread handling CStdRequest
// CStdPoolOfThreads -- pool of threads handling CStdRequest
//
/* abstract */ class CStdRequest : public CObject
{
public:
virtual ~CStdRequest(void) {}
// Called by whichever thread handles this request.
virtual void Process(void) = 0;
};
class NCBI_XUTIL_EXPORT CStdThreadInPool
: public CThreadInPool< CRef< CStdRequest >; >;
{
public:
typedef CThreadInPool< CRef< CStdRequest >; >; TParent;
CStdThreadInPool(TPool* pool) : TParent(pool) {}
protected:
virtual void ProcessRequest(const CRef<CStdRequest>;& req)
{ const_cast<CStdRequest&>;(*req).Process(); }
// virtual void Init(void); // called before processing any requests
// virtual void x_OnExit(void); // called just before exiting
};
class NCBI_XUTIL_EXPORT CStdPoolOfThreads
: public CPoolOfThreads< CRef< CStdRequest >; >;
{
public:
typedef CPoolOfThreads< CRef< CStdRequest >; >; TParent;
CStdPoolOfThreads(unsigned int max_threads, unsigned int queue_size,
int spawn_threshold = 1)
: TParent(max_threads, queue_size, spawn_threshold) {}
// void Spawn(unsigned int num_threads);
// void AcceptRequest(const TRequest& req);
// Causes all threads in the pool to exit cleanly after finishing
// all pending requests, optionally waiting for them to die.
virtual void KillAllThreads(bool wait);
protected:
virtual TThread* NewThread(void)
{ return new CStdThreadInPool(this); }
};
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// IMPLEMENTATION of INLINE functions
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CBlockingQueue<>;::
//
template <typename TRequest>;
void CBlockingQueue<TRequest>;::Put(const TRequest& data)
{
CMutexGuard guard(m_Mutex);
// Having the mutex, we can safely drop "volatile"
deque<TRequest>;& q = const_cast<deque<TRequest>;&>;(m_Queue);
if (q.size() == m_MaxSize) {
m_PutSem.TryWait();
NCBI_THROW(CBlockingQueueException, eFull, "CBlockingQueue<>;::Put: "
"attempt to insert into a full queue");
} else if (q.empty()) {
m_GetSem.Post();
}
q.push_back(data);
}
template <typename TRequest>;
void CBlockingQueue<TRequest>;::WaitForRoom(unsigned int timeout_sec,
unsigned int timeout_nsec) const
{
// Make sure there's room, but don't actually consume anything
if (m_PutSem.TryWait(timeout_sec, timeout_nsec)) {
m_PutSem.Post();
} else {
NCBI_THROW(CBlockingQueueException, eTimedOut,
"CBlockingQueue<>;::WaitForRoom: timed out");
}
}
template <typename TRequest>;
TRequest CBlockingQueue<TRequest>;::Get(unsigned int timeout_sec,
unsigned int timeout_nsec)
{
if ( !m_GetSem.TryWait(timeout_sec, timeout_nsec) ) {
NCBI_THROW(CBlockingQueueException, eTimedOut,
"CBlockingQueue<>;::Get: timed out");
}
CMutexGuard guard(m_Mutex);
// Having the mutex, we can safely drop "volatile"
deque<TRequest>;& q = const_cast<deque<TRequest>;&>;(m_Queue);
TRequest result = q.front();
q.pop_front();
if ( ! q.empty() ) {
m_GetSem.Post();
}
// Get the attention of WaitForRoom() or the like; do this
// regardless of queue size because derived classes may want
// to insert multiple objects atomically.
m_PutSem.TryWait();
m_PutSem.Post();
return result;
}
template <typename TRequest>;
unsigned int CBlockingQueue<TRequest>;::GetSize(void) const
{
CMutexGuard guard(m_Mutex);
return const_cast<const deque<TRequest>;&>;(m_Queue).size();
}
/////////////////////////////////////////////////////////////////////////////
// CThreadInPool<>;::
//
template <typename TRequest>;
void* CThreadInPool<TRequest>;::Main(void)
{
Detach();
Init();
for (;;) {
{{
CMutexGuard guard(m_Pool->;m_Mutex);
m_Pool->;m_Delta--;
}}
ProcessRequest(m_Pool->;m_Queue.Get());
}
return 0; // Unreachable, but necessary for WorkShop build
}
template <typename TRequest>;
void CThreadInPool<TRequest>;::OnExit(void)
{
try {
x_OnExit();
} catch (...) {
// Ignore exceptions; there's nothing useful we can do anyway
}
CMutexGuard guard(m_Pool->;m_Mutex);
m_Pool->;m_ThreadCount--;
}
/////////////////////////////////////////////////////////////////////////////
// CPoolOfThreads<>;::
//
template <typename TRequest>;
void CPoolOfThreads<TRequest>;::Spawn(unsigned int num_threads)
{
for (unsigned int i = 0; i < num_threads; i++)
{
{{
CMutexGuard guard(m_Mutex);
m_ThreadCount++;
}}
NewThread()->;Run();
}
}
template <typename TRequest>;
void CPoolOfThreads<TRequest>;::AcceptRequest(const TRequest& req)
{
bool new_thread = false;
{{
CMutexGuard guard(m_Mutex);
m_Queue.Put(req);
if (++m_Delta >;= m_Threshold && m_ThreadCount < m_MaxThreads) {
// Add another thread to the pool because they're all busy.
m_ThreadCount++;
new_thread = true;
}
}}
if (new_thread) {
NewThread()->;Run();
}
}
END_NCBI_SCOPE
/*
* ===========================================================================
*
* $Log: thread_pool.hpp,v $
* Revision 1.10 2003/02/26 21:34:06 gouriano
* modify C++ exceptions thrown by this library
*
* Revision 1.9 2002/12/19 14:51:00 dicuccio
* Added export specifier for Win32 DLL builds.
*
* Revision 1.8 2002/11/04 21:29:00 grichenk
* Fixed usage of const CRef<>; and CRef<>; constructor
*
* Revision 1.7 2002/09/13 15:16:03 ucko
* Give CBlockingQueue<>;::{WaitForRoom,Get} optional timeouts (infinite
* by default); change exceptions to use new setup.
*
* Revision 1.6 2002/04/18 15:38:19 ucko
* Use "deque" instead of "queue" -- more general, and less likely to
* yield any name conflicts.
* Make most of CBlockingQueue<>;'s data protected for the benefit of
* derived classes.
* Move CVS log to end.
*
* Revision 1.5 2002/04/11 15:12:52 ucko
* Added GetSize and GetMaxSize methods to CBlockingQueue and rewrote
* Is{Empty,Full} in terms of them.
*
* Revision 1.4 2002/01/25 15:46:06 ucko
* Add more methods needed by new threaded-server code.
* Minor cleanups.
*
* Revision 1.3 2002/01/24 20:17:49 ucko
* Introduce new exception class for full queues
* Allow waiting for a full queue to have room again
*
* Revision 1.2 2002/01/07 20:15:06 ucko
* Fully initialize thread-pool state.
*
* Revision 1.1 2001/12/11 19:54:44 ucko
* Introduce thread pools.
*
* ===========================================================================
*/
#endif /* THREAD_POOL__HPP */

复制代码

作者: JohnBull 时间: 2003-06-21 21:18
标题: c与c++区别讨论
证明我的水平差非常简单,我没涉猎过的领域非常多.

但是这仍然不能证明C++的先进性.
况且我也可以说

xxx代码是xx大师用C写的,你怎么写?
现在有了google,找到这样的"证据"非常简单啊.

C++的目标是成为一个OO语言,至少这一点是不争的事实,可以他在OO得并不彻底(毕竟它还有main函数啊).它在OO方面不如java,在PO方面又与C相当,只不过是用OO的思想对C进行了重新封装(就象加了一个层一样),重新编排了代码的调用模式,与C没有本质的区别.

至于什么大师之类的话就免谈了,咱们可以回想以下为什么会出现OO,不就是因为PO代码开发周期长,过程控制和质量控制不便吗?也就是说OO的目的是简化大型软件项目的开发.事事都把大师搬出来说话是不现实的,一个项目的开发成本恐怕不允许你雇一群大师吧?况且就算顾来一个大师,你舍得让他写底层代码吗?你难道不想让他做质量控制?最终去编码的不会有你所说的大师的.

作者: 大菠萝 时间: 2003-06-21 21:44
标题: c与c++区别讨论
在面向对象方面，C++是没有Java和C#做的好，毕竟他们都是后出的，但是，Java的速度是一个致命的地方，在很多的地方不能用Java来做（比如数据库的中间件，实时系统（我不是指在交换机上的那种），那我们就可以用C++了嘛，且现在的好多的大师级的人写了很多C++很好复用的代码，比如：上面讲的哪个ThreadPool，我的水平不够，那我就可以将大师的代码来复用嘛，将C的代码复用，我觉得太难了，让大师来进行软件工程，他们也是要考虑在公司已经有的代码的基础上来进行架构的，完全不考虑公司的现在的情况，就进行设计，那从软件工程的方面来说，风险太大了。
JohnBull兄这么喜欢Java，Java是好，可是大工程不能总是用JNI来将核心C和架构的Java来接起来吧！用C++，不是更好吗？（有时候核心代码很大的，比如我上面贴的哪个“National Center for Biotechnology Information”，用C写，就可读性太差了，可能是我的水平不够，Apache的C源码，我看了就头晕，好多的struct ,好多的函数）。

现在C++是越来越收到Java和C#的压力了。不过Java主要做网络方面的。我想C++还是有饭吃的。JohnBull兄，你认为了？

作者: tinywind 时间: 2003-06-21 23:21
标题: c与c++区别讨论
我觉得c++的问题是太想大小同吃了，既要有c的速度，又要支持面向对象，现在又加入模版，最后让自己变得极其复杂，至今还没有一个完全支持标准的编译器。不过这样可以让c++程序员的自尊心得到极大满足。
另外一方面，unix对c的支持要远远好于c++，我想这也是unix上c更受欢迎的原因吧。

作者: 无双 时间: 2003-06-21 23:48
标题: c与c++区别讨论
JAVA和C++相比
一个是性能
另一个是对系统调用的操作

性能的话因为有虚拟机所以会比C++低

JAVA因为要设计成所有平台上都运行
所以在使用系统调用方面比不上C++

但是JAVA的一个优势是跨平台,这些虽然C++可以通过在不同平台上使用不同平台库实现
但是还不如JAVA方便, 因为JAVA不用再编译

所以JAVA以后的方向会是应用方面
C++以后方向在服务器程序方面

C++的模板等都是为了使程序设计更方便
如STL可以让你不用再为管理内存而分心
我觉得也是一个优势

至于没有完全支持标准的编译器
我觉得这不可能
GCC是不想购买认证
MS VC的STL用自己的一套
其它的我想会有支持标准的
因为让一个编译器支持不是很难，只是想不想

作者: 夜未眠 时间: 2003-06-22 01:44
标题: c与c++区别讨论
我觉得最大的不同就是c++的开发工具要明显多并且好过c的.
个人观点.仅供参考

作者: 无双 时间: 2003-06-22 14:52
标题: c与c++区别讨论
c++中有了STL后
我觉得是方便多了

很多基本数据结构都可以直接使用STL实现

作者: gadfly 时间: 2003-06-22 17:49
标题: c与c++区别讨论
说来说去，C++和java在OOP方面想比都是有先天的不足。面对对象的支持在Java上是彻底的。而C++需要兼容C，也可以说是对C的封装来满足OOP的编程。

举几个例子,例如：

1.多形的支持，方法的动态绑定在java中是缺省就支持的，在C++中却需要
virtual的关键字来支持。

2.指针和生存期，C++都需要费心的考虑，对一般开发人员来说是个很重的负担。JAVA中，这些都是JVM，垃圾回收做的事情。

3.单根体系，JAVA贯彻的思想就是Everything is object.所以所有的class都有共同的祖先Object。这给接口的设计，以及JVM的实现带来很多的好处。我就直接摘录TIJ中的这段。

One of the issues in OOP that has become especially prominent since the introduction of C++ is whether all classes should ultimately be inherited from a single base class. In Java (as with virtually all other OOP languages except for C++) the answer is yes, and the name of this ultimate base class is simply Object. It turns out that the benefits of the singly rooted hierarchy are many. Feedback

All objects in a singly rooted hierarchy have an interface in common, so they are all ultimately the same fundamental type. The alternative (provided by C++) is that you don’t know that everything is the same basic type. From a backward-compatibility standpoint this fits the model of C better and can be thought of as less restrictive, but when you want to do full-on object-oriented programming you must then build your own hierarchy to provide the same convenience that’s built into other OOP languages. And in any new class library you acquire, some other incompatible interface will be used. It requires effort (and possibly multiple inheritance) to work the new interface into your design. Is the extra “flexibility” of C++ worth it? If you need it—if you have a large investment in C—it’s quite valuable. If you’re starting from scratch, other alternatives such as Java can often be more productive. Feedback

All objects in a singly rooted hierarchy (such as Java provides) can be guaranteed to have certain functionality. You know you can perform certain basic operations on every object in your system. A singly rooted hierarchy, along with creating all objects on the heap, greatly simplifies argument passing (one of the more complex topics in C++). Feedback

A singly rooted hierarchy makes it much easier to implement a garbage collector (which is conveniently built into Java). The necessary support can be installed in the base class, and the garbage collector can thus send the appropriate messages to every object in the system. Without a singly rooted hierarchy and a system to manipulate an object via a reference, it is difficult to implement a garbage collector. Feedback

Since run time type information is guaranteed to be in all objects, you’ll never end up with an object whose type you cannot determine. This is especially important with system-level operations, such as exception handling, and to allow greater flexibility in programming. Feedback

当然，我不是说C++和JAVA比一无是处，我觉得是各有适合的场合。例如一些标准的网络服务，对性能要求很高的应用，适合于用C/C++开发。
但是从长远来看，基于WEB的商务应用，JAVA的用武之地更多一些。

作者: fsb 时间: 2003-06-22 20:06
标题: c与c++区别讨论
漏了说泛型吧. 现在java也开始要增加泛型功能.

作者: mengwg 时间: 2003-06-22 20:14
标题: c与c++区别讨论
嘿嘿，用java写个数据库试试

作者: 大菠萝 时间: 2003-06-22 20:47
标题: c与c++区别讨论
呵呵，其实，BarkDB(好象是这个名字，是一个嵌入的分布式数据库）就是用java写的，是一个十分著名的数据库，15000行代码，每秒响应150个事务请求。

作者: 无双 时间: 2003-06-22 22:27
标题: c与c++区别讨论
150个事务请求性能也是够高的了
以前测试MS SQL时性能还不到100
测试ORACLE时好像是一秒250个请求左右

当然数据库在并发性时性能也要测试的
不然如果只有一个连接, 那么做成串行的话性能当然很快了

作者: tinywind 时间: 2003-06-23 10:21
标题: c与c++区别讨论
很多人对java性能的理解都受了gui的影响，因为java的swing实在太烂，大家直观的感受就是java太慢。其实在后台服务方面，java和c的性能差别并不大，我作得一些测试中java还超过了c。

关于c++的编译器，我去年看stl的时候还没有完全支持标准的，g++是支持最好的一个，不知道最新的g++能否完全支持。

作者: 无双 时间: 2003-06-23 10:37
标题: c与c++区别讨论
不是受GUI影响
而是因为JAVA需要一个虚拟机

运行虚拟机速度不会比得上运行机器码速度

STL的标准SGI的库应该全部支持了
因为STL后面许多新东西都已不再添加到里面去如HASH这个有用的数据结构
MS不使用SGI，也不支持标准，我想可能是因为MS有自己的一套容器标准，就是MFC内的CSTRING等，想用MS系统的广大用户影响STL标准的创建从他对JAVA的态度上也可以看到这点

还有楼上的测试是什么条件的，可否说一下
虚拟机速度如果可以比机器码速度快
那么GCC确实需要改进了

作者: 大菠萝 时间: 2003-06-23 10:39
标题: c与c++区别讨论
java还超过了c?疑惑中

作者: 蓝色键盘 时间: 2003-06-23 11:04
标题: c与c++区别讨论
C是一个结构化语言，如谭老爷子所说：它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。
所以C与C++的最大区别在于它们的用于解决问题的思想方法不一样。之所以说C++比C更先进，是因为“ 设计这个概念已经被融入到C++之中 ”，而就语言本身而言，在C中更多的是算法的概念。那么是不是C就不重要了，错！算法是程序设计的基础，好的设计如果没有好的算法，一样不行。而且，“C加上好的设计”也能写出非常好的东西。
对语言本身而言，C是C++的子集，那么是什么样的一个子集？从上文可以看出， C实现了C++中过程化控制及其它相关功能，而在C++中的C（我称它为“C+”），相对于原来的C还有所加强，引入了重载、内联函数、异常处理等等玩艺儿，C++更是拓展了面向对象设计的内容，如类、继承、虚函数、模板和包容器类等等。
再提高一点，在C++中，数据封装、类型这些东东已不是什么新鲜事了，需要考虑的是诸如：对象粒度的选择、对象接口的设计和继承、组合与继承的使用等等问题。
所以相对于C，C++包含了更丰富的“设计”的概念，但C是C++的一个自洽子集，也具有强大的功能，同样值得学习。

几点学习建议：
1．基本概念很重要。无论学C，还是学C++，基本概念都是第一位的，也是比较困难的，但只有把握了基本概念才能把握整体脉络，才能居高临下。
2．C是C++的子集，它的基本概念和设计方法相对比较容易理解，初学者可从它入手。
3．如果要学好C++，建议初学者最好别在如VC，BCB平台下写程序，那种自动化的代码生成，花花绿绿的界面，会让你手足无措。最好先找一片空地（unix，dos），从头做起，写几个大点的程序，数个回合，再到VC，BCB下看看，你会轻松得很。在我看来，学好C/C++是成为VC，BCB高手的必由之路。
4．不要妄想速成，必须得一个byte，一个bit的去抠，尽量搞清楚每一个问题。
5．几本好书：
机械工业出版社的那套“计算机科学丛书”从C到C++，到面向对象设计，一应俱全，都TMD是经典中的经典，而且价格公道，童叟无欺。
国内也有几本好书，谭老爷子的书好倒是好，就是程序错误太多。强烈推荐清华周之英的《现代软件工程》（上、中、下），它是我所见到的国内少有的一本好书，精华的精华，要点的要点，细细品来，至少也属降龙十八掌等级的东东。

作者: 蓝色键盘 时间: 2003-06-23 11:08
标题: c与c++区别讨论
看看一个网友对于c和c++的描述，挺有意思。

想学好C++，非学C不可！！！

今天我这么肯定的在这里讲这番话，是不想初学者陷入到语言越新越好的误区，本来这个题目就不是很严谨，但是我有几句话必须讲讲，为C平反！！

C++与C有什么不同呢？我们现在一步步地来分析一下
一、类，类我并不说它有什么不好，但是对于初学者，它是一个累赘。类的封装使得初学者对程序产生厌倦，感到不适和麻烦。
二、引用，引用是C++中最臭屁的东西了，最好尽量不要用它，我就是从来不用引用，除非万不得已。引用对于初学者就更容易产生混淆，不知道哪个是引用，哪个是变量。
三、函数的重载，初学者学函数的重载好像没什么坏处，但是，这会使初学者潜意识里对C语言的变量类型的重要性产生淡化，要记住C语言是对变量类型最敏感了的，变量的类型在C语言里的重要性是不言而喻的。
四、流操作符，和上面同样的道理，使得对变量类型的重要性产生淡化，况且，cin这个东东有点儿不怎么方便，有时会产生使初学者莫名其妙的结果。
五、操作符重载，典型的高级应用，初学者可能根本用不着，这个东东会让他们觉得C++很难，门槛高，看不懂…………。
六、继承，以及虚函数，典型的模仿四不象，这种狗屁东西除了看起来深奥，实用价值很低………………。我怎么可能把某个类的类型的指针去指向另一个不同类型但是是继承关系的类，来实现什么动态联编，晕…………
………………还有些东东我就不发表评论了，如：new,delete操作符等…………

七、误区：以问答形式：
问：C++是面向对象化的而C是面向过程化的？
答：第二对，第一问错，C++并非完全面向对象化，真正的面向对象化的语言恐怕只有Java才算得上。
问：C++能实现C所不能的功能吗？
答：至少我还没有发现……
问：学了C再学C++有障碍吗？比如程序设计思想……
答：至少我还没有看见谁有此症状。
问：学了C再学C++又要重头开始吗？
答：不，C++下可以实现C语言的一切功能。
问：我学完了C一定还要学C++才能编程吗？
答：完全没必要。
问：C++比C好在哪里？
答：更加符合软件工程学
问：学完了C再学C++是不是很容易？
答：那要看你是不是真正的学完了C语言，我从C到C++就一个星期的睡觉前的时间看两眼书，然后就大彻大悟。再跑到这里来发表些狗屁文章了。

最近在网上看到了很多人的学习方法，本人非常不赞同。很多人都想一口吃个胖子，要学就想学最新的，好象没有人愿意再去学那些老的，旧的编程语言了。但你们能学的懂吗？不学TC2。0等那些较早的优秀编程语言，你们能理解的了VC6。0？如果你真的能，我宁愿做你的徒弟！真是奇怪，那些最基本的语言都不懂的人，怎么可能去理解那些最新的编程语言？我学编程有三年了吧。成绩也不算多，只有一个计算机四级证和一个高程证，但我觉得我在学VC的时候还有很多的不明白的地方。没有人来教我，只能靠我自己，包括所有的成绩在内，我都是靠自己，我从不报班。学VC的半年多来，我想我已经基本入门，但依然有很多的困惑。刚开始学VC，就面临一个项目，我真的犹如笨蛋一般，四处吓摸，毫无头绪，最后勉勉强强才算做个差不多。学好VC再去学其他的高级WINDOWS编程，我想那真是轻而易举，毕竟WINDOWS的内部的很多东西都能直接被VC调用，你首先就可以对WINDOWS有个全新的认识，再去学其他的语言岂能不简单？

我的感觉是，面向过程和面向对象，其实都很重要的，在VC里也依然需要面向过程，很多东西都是一环扣一环，没有面向过程的思想，怎么可能去编程呢？建议多去看看有关WINDOWS编程的书，但多数都是比较老的书呦！我依然记得当年整天进行TC编程的辛苦，但我依然很怀念当年的劳动付出，毕竟我获得了我想获得的一切——编程思想。我觉得一个好的编程思想，绝对比你去学一门计算机语言好重要的多。要形成自己的编程风格。一个好的编程思想在你的头脑中一旦形成，学习什么语言都会很轻而易举，因为此时的你不在是简简单单的学习，而是来验证！

作者: 无双 时间: 2003-06-23 11:09
标题: c与c++区别讨论
总结得不错
顶

作者: 蓝色键盘 时间: 2003-06-23 11:10
标题: c与c++区别讨论
从编译器的角度看看c和c++，便明白其中联系和实现细节。

大家看WIN32 SDK的头文件,总是可以看到

　　　　#ifdef __cplusplus
　　　　extern "C" {
　　　　　　　　#endif

　　　　　　　　#ifdef __cplusplus
　　　　　　　　}
　　　　#endif

　　这个就是直接能够体现实际编程时区别的地方. 在WIN系列下.所有的WIN32 SDK提供的LIB都是以C的形式存在的.当然,C和C++同样都支持C,STDCALL,FASTCALL调用.为什么系统提供C编译器编译的LIB而不是C++编译的LIB呢?这里其实就是C和C++编译器不同的地方.

　　所有的函数名称只有在汇编编译器下才最清楚.因为经汇编编译器编译的函数不经过任何修饰.
C的编译器编译出来的函数名称如果在汇编编译器看来一个C调用将在函数名前家下划线('_').而一个STDCALL的函数将是_FUNC@NUMBER的形式.如FUNC(void)经过编译器后成为_FUNC@0.一个FASTCALL调用的函数被编译成@FUNC@0.顺便提一下.在WIN32的编译器里不再需要PASCALL调用.VC6已经取消了对PASCALL的支持.
光看C的编译还不够,看一下C++编译器是怎么干的.在缺省情况下.一个C++的函数经过C++编译器后编译出的函数名包括函数名,所属的类,参数类型,调用约定,返回类型.而且更要命的是这么多的信息,只有函数名和类名在编译后还依稀可见.其他就是一长串的ABCD字母,根本就是无法辨认其意义的.我们在VC手册里可以看到

一个例子:

void __stdcall b::c(float){}; ----------->; ?c@b@@QAGXM@Z
　　一个函数被编译得连名字也不知道怎么样了.这么一来.如果SDK提供的是C++编译器提供了LIB.那么可以说就无法编译任何一个完整的WIN程序.更加不用说什么混合语言编程.

　　现在,VC编译器提供了个extern语句.当出现extern 'C'{}语句,括号里的函数将以C方式经过编译器.从而使提供库程序方便那么点.

作者: 无双 时间: 2003-06-23 11:20
标题: c与c++区别讨论
虽然实现是这么实现的
但是我觉得可能也是为了兼容性考虑

因为许多程序都是用c与的
所以提供C接口
另外由于C++支持C
因此只要提供一个接口就可以了
保证系统的简洁

另外系统本身也是用c语言写的
所以可以提供原来的函数让外面调用
封装机制由外面决定

作者: 蓝色键盘 时间: 2003-06-23 11:20
标题: c与c++区别讨论
我在灌点！呵呵

www.chinacs.net 有人这么评价的，随便看看

关于两代语言.C/C++,java/c#
不要以为这个题目是耸人听闻,但就目前的形势来看c/c++是需要退出舞台或者说的婉转一点是需要更新换代了.
我想在未来的一两年里,作为程序员等级评判的标准之一c/c++(不管是mfc还是bcb)将会让位给三种编程语言,1.sun的java2.windows平台上的c#3.xml
为什么这么说呢,我认为最大理由是目前的应用程序正在从基于独立的操作系统,传向基于internet平台.
我们以前开发应用程序都是依赖于平台的功能调用,mfc,bcb都是这样.而现在日益火热的internet编程却最不想关心的就是某一个平台的调用,譬如说要实现b2b的电子商务那么就需要做不同平台的集成,如果我是程序员我最care的就是如何实现商务逻辑
而不是各种平台之间的通信和管理.那么我们最迫切需要的就是一种与各种平台调用无关的语言,这中语言只注重程序逻辑的设计而不涉及平台的调用.而我们熟悉的c/c++却恰恰不是为这个而设计的(赫赫这也不能怪c/c++在70年代谁能知道现在internet的情况呢).c/c++的最初设计目的是为了设计unix产生一种介于汇编和高级语言之间的一种开发高效而性能不低的语言.他要比其他任何高级语言都要关心系统的物理结构,譬如一直是毁誉搀半的指针.指针之所以强大就是应为涉及了系统物理内存的管理.他可以使得程序员和系统之间成为一种半透明状态.但是就是这种半透明的状态让指针带来了更多的不稳定性.
c/c++在面向Internet的编程中却无任何优势可言.跨平台的电子商务软件最害怕顾及各种平台之间的天差地别的系统调用,最害怕时不时的由于内存泄漏而crash.c/c++的优势在这里却成为了劣势.即使在windows平台上开发基于windows dna的solution
用的最多的还是vb做的dcom而不是vc的atl做的dcom,因为c/c++虽然高效但是太容易
出错,如果不是很小心的释放内存nt很快就会资源不足.
java就是最先看到这种情况,他用jvm实现了平台无关用内存回收实现了稳定健壮.但是相当多的c/c++程序员抱怨java太慢了.的确即使到java2速度仍然是一个大问题.我曾经是一个c/c++坚决拥护者在许多论坛里和java程序员打笔仗.但是我逐渐意识到面对与internet平台而不是特定的操作系统的时候java的速度问题往往是一个小小的瑕疵.我们可以想象那一个电子商务网站会用我们手头的pc做服务器,他们不是sun的e1000就是ibm的risc6000.在这种平台上java这点速度问题只是a peice of cake.程序员只需要专注与商务逻辑的编程,而不必要关心数组是否越界,对象内存是否释放更不需要关心是不是unix和windows的系统调用不一样.
微软的c#可以说是一种java与c/c++的杂合体,他可以回收内存,可以平台无关.但是
他又可以实现一些java没有的功能譬如在标记的程序段内用指针自己管理内存,可以实现操作符的重载等等.为什么要这样做我想也许c#还肩负了一定的面向操作系统开发的任务例如winform.他基本上的思想和java类似,但是实现的方法又不一样他不通过jvm解释中间代码,而是吧源代码编译成p代码然后通过CLS库和JIT在平台上及时编译为100%的本地代码来执行.他的pe代码是独立于平台的,但是cls和jit却根据不同的平台而设计.因此c#的平台独立有点类似于c/c++在不同平台上的移植使得c#比java来的更快.而且微软还许诺cls和jit不仅针对c#还可以针对任何语言譬如pascal,smaltalk,basic因此将来有可能所有的编程语言都是可以平台无关的(ms真是毒,所有的语言都平台无关java还有什么优势呢,据说ms正在开发基于pascal smaltalk的asp+).
xml很多人可能认为与html相类似的语言和c/c++,java,c#完全不在一个档次上的语言.其实不然.我们知道不管是c#还是java都是通过统一地层计算来实现平台无关.那就必须在性能上付出一点代价.而xml却能够实现不同的语言之间的调用.譬如说一个网占用java用bean实现一个出货功能,另一个网站用dcom实现一个入库功能 .如果这个网站需要实现b2b,用一般的方式就是在他们之间写转换程序.而xml通过标记语言来描述各自的借口特性.两端通过解析xml文本来实现互相的调用,无需任何中间转换程序
只要一张xml文本就能实现bean和dcom之间的通讯(要说清楚其中的机理,需要很多xml概念如果有兴趣可以到msdn.microsoft.com/xml或者www.s3c.org去看看).目前ms的.net中最核心的技术soap就是完全基于xml的远过程调用.
介绍了那么多可能有点跑题,其实我最想说的就是21世纪的程序员应该从面向操作系统的传统方法中走出来,学习一点如何面向Internet平台编程的技术和概念.不要在无畏的那种c/c++工具好之类的地方争论.我想不出一两年不管是bcb还是mfc都要淘汰,
到那个时候要争论的不是bcb好还是mfc好而是c#好还是java好.至于xml那是不管sun和ms以至于世界任何大的IT公司包括Intel,hp都在奋力研究的技术,不学习可能就要被淘汰.至于c/c++可能就会沦落到现在汇编的地位在某些系统效能敏感的地方还能见得到.
如果是编程语言的初学者那么我建议学习java同时关注c#,他们首先比c/c++简单没有复杂的宏,指针,摸版等等让人摸不招头脑的概念.而且是完全面向对象,比c/c++的半调子面向对象清楚的多好学的多.(我推荐目前学习java,毕竟c#还没有发布而且刚发布的beta版的编译器要求高的吓人需要win2000 adv server没有128M内存的别想跑.话说回来c#和java一摸一样没有什么太大的区别学好了java将来的c#将会信手拈来)
对于目前的windows下的编程者来说学习mfc的价值还是有一点的但是不是太大.至少可以熟悉windows内在机理.但是我还是推荐关注一下c#将来的windows.net都是基于c#而不是mfc.而且c#要比mfc简单的多实现一个同样的windows桌面应用c#的开发速度是mfc的两到三倍而且几乎看不见性能的损失. visual studio 7.0中 vc将是一个次要的开发工具最主要的开发工具就是c#和vb7.0.至于borland我想是不可能不跟着ms走至少windows平台上是这样说不定明年就有一个c# builder出来作为borland的主打产品而不是c++builder了.说一句玩笑话wenny说不定很快会把这里变成www.c#help.net了

作者: 大菠萝 时间: 2003-06-23 11:29
标题: c与c++区别讨论
c#是不错，它的编译器是编译器的泰斗编的，（特牛，Bill从baland挖的,pasic的创始人，两个月（好象）编出了Dephi的模型),是不错的语言，可能有抄袭Java的嫌疑，但是我觉得，别人做的好，自己来学习，有什么不对了。
现在的windows, java虚拟机的API都慢满的转为类形式的了，用C来做API，我觉得没有.net 和Java的API好用。

作者: 无双 时间: 2003-06-23 11:42
标题: c与c++区别讨论
java和c/c++的比较在软件技术版的那篇文章也谈过了
这里再写一次

我觉得性能方面他们都没有考虑
c#和java的性能方面都比不上c++
在一些对性能要求严格的地方
如服务端
以后还是会使用c/c++,要处理几十个连接并通过虚拟机处理那么硬件上的投入更高
并且服务端没有必要使用跨平台属性

另外java与系统的集成方面不好

通过虚拟机形式
所以想直接调用系统函数不可能
只有虚拟机上有的函数才可以用
这也是跨平台带来的代价

c#的话只是在ms平台上开发
会遇到unix世界公司与多数开发人员的抵制(因为是ms的产品)
性能也不用说了据说比java还要慢很多还是等待MS的下一个版本吧

XML只是定义一种数据保存格式.用来统一各程序使用数据的一致性,
与程序设计语言无关,所以原作者放在这里觉得很奇怪
保存的文件会比二进制的大,并且需要先用xml分析器分析, 性能方面也比不上二进制文件保存，
但是比较直观,并且统一,以后的用途是代替以前的.ini等配置文件和使用文本形式保存数据的、有可能要在多个程序间使用的文件
使用xml,可以让金山不再出现wps2002打不开wps2000的现象

对一些对性能要求很高的数据不会以XML形式保存，如TCP/IP包等协议包

最后觉得这个作者是对c/c++不是很熟练的人
真正熟练的人不会说哪种语言好哪种不好
每个语言都有自己适用的场合, 就是在现在, 汇编还是有人在用,用于开发嵌入式方面,还有cobol等
所以关键不是看哪个语言好
而是要看找它的定位
VB虽然可以做很多事，但用它开发系统内核那么就不合适
它只是家位在一个快速开发工具而不是开发系统级应用

如果是定位于应用的话
java应该是首选
不再让各位受到操作系统大战的连累

作者: 蓝色键盘 时间: 2003-06-23 12:08
标题: c与c++区别讨论

每个语言都有自己适用的场合, 就是在现在, 汇编还是有人在用,用于开发嵌入式方面,还有cobol等
所以关键不是看哪个语言好
而是要看找它的定位
VB虽然可以做很多事，但用它开发系统内核那么就不合适
它只是家位在一个快速开发工具而不是开发系统级应用

复制代码

恩。无双写的太好了，有道理。

一种语言，一旦被大家认识了，一旦有不少人去做点什么东西，就意味着它有一定的生命力和用途。现在很多人不用汇编了，这能说明汇编没有用吗？不是，只能说，你做的应用是和汇编不直接相关的而已。
c没有c++/java/c#优越吗？也不是，如果做系统软件，用c可能算是最省事的选择了。

我始终认为c++便是对c的扩充而已。只不过在c的基础上努力的去实现OO的思想。一方便，是为了兼容c,一方面是为了OO，也许就是这种二者兼顾的思想导致了c＋＋的不彻底。

如果说正真的面向对象。我觉得还是java。c#我不懂。也不敢评价什么。

至于性能，我觉得有个比喻说得挺好：越是好用，也越耗油。
例如java，要实现跨平台、继承、引用以及垃圾回收容器等这些机制，必然要加入大量的额外代码和函数封装。

没有谁是做好的说法。如果能在最短的时间和最底的成本下能够开发出符合需求的软件，那么这个工具就是优秀的。

在做一个系统之前，我总是在考虑用那个工具最快，最省事这些因素。

还是商业的那句话，只要有需求，就有产品。
否则，我们可能没听说过的东西太多了，完全有可能就是JAVA这个名词。

作者: fieryfox 时间: 2003-06-23 12:10
标题: c与c++区别讨论
好热闹啊。可是热闹了半天好象也没什么意义（没有贬义）。

如果单纯是讨论楼主的问题：C与C++区别讨论，我想限制在语言上就可以了。简而言之一句话：C++是C的扩展，提供了...特性。

可是高手们都说了，C++是一门全新的语言？！。不错，很多高手都这么说了，而且经常作为对低手的谆谆教诲来说的。可是那主要是指程序设计开发的思想，这已经不属于语言的范畴了。软件工程有那么多阶段，coding只是其中的一小个阶段，所用的语言也只是一个工具而已。当然工具能够提供什么强有力的能力，可以使开发更顺利是很重要的，可先人们没有打火机也一样吃烧烤，当然钻木取火还是比较费力气的。

争论哪种语言好没有意义。每种语言都有它适用的范围，有它比别的语言强的地方。比如我想让你处理一个文本文件，提取一些内容，你非要用C++或C#或者Java给我做，免了，我用awk或perl这样的语言会做的又快又好。可是如果让你写一个窗口系统，你非要用C，那Xt就是一个例子了，用了复杂的方法去实现封装和继承，还有不得不满天飞的全局变量（当然用一些技术可以避免，但额外的维护工作量不可小觑）。这时，选用支持面向对象方法的语言就是必然的了。

所以，有什么样的需求就应该有什么样的产品，所有中间过程使用的方法、工具都是为这个目标服务的。面向对象还是面向过程还是面向XX，都只是为了能够简单、明了、高效的实现需求。撇开需求谈这些，和哲学家咬文嚼字就没什么区别了。

作者: 蓝色键盘 时间: 2003-06-23 12:14
标题: c与c++区别讨论

所以，有什么样的需求就应该有什么样的产品，所有中间过程使用的方法、工具都是为这个目标服务的。面向对象还是面向过程还是面向XX，都只是为了能够简单、明了、高效的实现需求。

复制代码

严重同意。

我们还是不要谈论那个好坏的问题，还是谈谈具体语言的区别吧。

作者: 无双 时间: 2003-06-23 12:17
标题: c与c++区别讨论
嗯
楼上各位发言都很精彩

做一个系统
考虑的是怎样能更快更好的实现用户需求
并且设计实现更简单,就是从用户角度来考虑而不是从程序员角度考虑
做项目并不是为了表现程序员的某个编程技巧而是看整体结果

就是数据库和运行平台, 根据性能也有选型的说

语言只是一种工具
coding只是入门, 更重要的是编程思想与软件设计方法

作者: tinywind 时间: 2003-06-23 12:54
标题: c与c++区别讨论
关于java超过c的测试，其实很简单，就是一个上千万次的累加。当时是一个c的拥护者说这个测试c比java快二三十倍。我当时不信，测了一下，在x86平台下java的速度是c的80％左右，在hpux和aix下结果令人吃惊，java比c还要快。我也不能很好解释，大概是这些平台的jit技术比较优秀，java真正在运行时都是直接运行本地码了。

大家有兴趣可以验证一下。

作者: 无双 时间: 2003-06-23 13:05
标题: c与c++区别讨论
哦
也有可能是内核进行了优化

作者: 蓝色键盘 时间: 2003-06-23 13:16
标题: c与c++区别讨论
有可能，我用hp比较多的，我觉得是比较不错的unix OS。

作者: zhangpiwang 时间: 2003-07-04 23:19
标题: c与c++区别讨论
精彩，我要用digital c++ 做点应用，第一次用c 或c ++做实际的开发，digital的cpu说是最好的，我也来试验一下，我说的是废话，算作顶

作者: startdd 时间: 2003-07-05 00:06
标题: c与c++区别讨论
Java 的缺点通常不被人知晓，因为比较隐藏！

Java是当今使用最广泛的编程语言之一。自1995年发布以来，一直被用户高度评价为“消除了C++缺点的优秀编程语言”。不过，随着它的广泛使用，其缺点也在逐步地表现出来。

　　Java的缺点公认有如下三点：（1）存在非对象的数据类型；（2）不能够用一种描述方法来表达各种类（Class）；（3）无法继承2个以上的类的装配。虽然也有人认为编程语言应该是一个什么样子会因人而异，不应该算成缺点。不过，上述三点却可以导致编程人员使用混乱，降低源码的可读性及程序的可维护性。

存在非对象的数据类型


Java的原始类型（Primitive）。原始类型包括表示真假的布尔型（Boolean）、字符型和数值型等

　　第一缺点是指虽说Java是面向对象的编程语言，但却存在非对象的数据类型。

　　“面向对象”的定义虽然有很多种，但无论何种定义，其最基本的概念都是利用包含数据和步骤的“对象”来表达系统。即便在Java领域，也会使用名为类的模型生成对象，并通过调用它的方法组织程序。

　　但是，其中却混杂着非对象的内容。原始类型又被称为基本数据类型）。用于处理文字的char（字符型）、表示真假的boolean（布尔型）、int以及float等数值型就属于这种数据类型。

原始类型的内存管理方法不同


Java的内存管理方法。Java内存区包括保存本地变量的内存堆栈区（stack）和保存对象的数据的内存堆区（heap）。堆栈区中存放的是用于引用（reference）对象时所需的信息

　　原始类型和对象型的内存管理方法不同。Java虚拟机所管理的内存区包括内存堆栈区和内存堆区。内存堆栈区用于存放本地变量的数据。按堆出的顺序保存本地变量的数据。一旦脱离变量的有效范围，该数据立刻就被释放。

　　而内存堆区则用于存放对象本身。生成对象型的变量后，首先在内存堆栈区中为其准备存放位置。然后利用new运算符在这个位置生成新的对象后，对象及其数据就被存放到内存堆区。接着，内存堆区中的对象位置就会作为对象型的变量数据而被写入内存堆栈区。由于这些是引用对象时所用的信息，因此对象型变量被称为“引用型”。

　　而实际数据本身被写入内存堆栈区的是原始类型。采用这种内存管理方法的类型称为“数值型”。

　　引用型变量改变以后，就会引用保存内存堆区中的实际的对象数据，重新改写数据。比如，在方法的引数（arguments）中描述对象型变量时传递给方法的就是存放在这个位置中的信息。所以在方法内追加的变更还会被反映到调用的原始对象上。另一方面，数值型变量传递的是它的值。即便在方法内部进行了变更，也不会反映到原始变量中。

无法使用对象所具有的功能

将数值数据保存在Java的矢量类中的程序。生成Integer类，然后封装（Wrap）数值
将数值数据保存在Java的矢量类中的程序。生成Integer类，然后封装（Wrap）数值

　　由于原始类型与对象型的内存管理方法不同，因此就无法生成统一两种数据的类库。比如，如果只是对象型数据就能够构筑包含任意数据的类库。

　　可变长的数组类就是其中的一个例子。它是作为名为java.util.Vector的类而生成的。可以将任意的对象追加到数组中，还可以提取或删除。能够以此为引数指定任意的对象。但是，由于原始类型数据不是对象，因此无法直接引入。

　　因此在Java中还存在相当于原始类型的类。比如int型变量就可以使用java..lang.Integer类。重新生成Integer类，然后保存数据，就可以追加到Vector矢量类中。

　　但是稍微想一想就会明白，这种方法并不是很灵活的做法。由于加入了多余的代码，因此看起来感觉比较乱。而且还会浪费内存空间。原来的值暂且不说，还必须确保新建对象所需的内存。不仅存在表面上的问题，还存在实质上的问题。就是说无法保证数据的同一性。作为对象型保存的值与作为原始类型而保存的值完全不同。即便改变了原始类型的值，也不会反映到原来的int型数据。

C#利用Boxing（装箱）解决的只是一部分

　　这一问题并非是Java特有的。比如，作为与Java类似的语言为用户熟知的C#也存在相同的问题。C#利用称为Boxing的方法部分地解决了这个问题。但是所解决的也只是可以不写多余代码的部分。内存问题和同一性问题仍旧存在。

　　即便C#，int、double和char等数据类型也无法作为对象进行处理。这些数据类型与Java的原始类型相同，也是数值型变量。

　　C#可以将其值代入到对象中。已经将int型的值代入了对象型变量。此时先进行装箱，之后就开始悄悄地把基本数据类型的数据转换成对象型数据。在内存堆区中确保相应的内存，然后将数值型数据保存。对象型变量引用的就是这些数据。


执行装箱的C#代码。将数值直接代入对象中。运行代码后，输出0和1。也就是说变量a和o没有同一性


C#中的装箱法。对存放于内存堆栈区中的int型结构体（structs）装箱时，就会悄悄地在内存堆区中生成对象。因此就无法确保与初始值的匹配性。

　　利用装箱法，用C#试着写了一段与在Java的Vector矢量类中保存数值类似的代码。虽然ArrayList类要引数中提取对象型变量，但这里由于通过直接int型变量，因此代码非常整洁。

　　不过，并没有解决多余的内存消耗和数值的同一性问题。因为只是单纯地实现了自动向对象的转换。


与LIST 1起相同作用的C#代码。由于具有装箱法，因此可以直接向ArrayList中追加数值


利用Java和C#，将int型变量转换成对象的方法。尽管内部处理基本相同，但C#的特点是隐式转换

如果考虑到实用，也算得上是优点

　　从上述所讲来看，就会生出这样的疑问：为什么最新的Java和C#语言还存在着这样的问题呢？实际上这是因为对其性能的重视。

　　由于原始数据型数据在编程时使用得最多，因此利用能够对其进行快速处理的原始类型，性能就会提高。而对象型数据在生成对象，以及使用位置信息去引用内存堆区中的数据时则会产生一定的开销。另一个问题是内存堆区。如果全部是对象型，比如，只要执行简单的for循环语句，就会在内存堆区中生成大量的对象。由于内存堆区的消耗速度就会急剧上升，并且频繁地进行资源回收处理，因此性能就会降低。

　　Java和C#是考虑到性能问题才生成原始数据型数据的。因此并不能说是“纯粹的”面向对象语言。也许可以说是考虑到实用性的稳妥做法吧。

作者: odin_free 时间: 2003-07-05 20:11
标题: c与c++区别讨论

原帖由 "无双" 发表：
做一个系统
考虑的是怎样能更快更好的实现用户需求
并且设计实现更简单,就是从用户角度来考虑而不是从程序员角度考虑
做项目并不是为了表现程序员的某个编程技巧而是看整体结果

?.........

真是如此我个人感觉你想入哪个方向就决定了你所选择的大体语言

不如你要做嵌入式开发或者做算法实现驱动程序编写

c应该是更好的语言

而如果去做应用软件 oo语言就更加得心应手

在同样的方向上不妨自己尝试比较几次

没有绝望的痛苦还是很难写出真实的感想

作者: mengwg 时间: 2003-07-05 20:34
标题: c与c++区别讨论
JAVA不错，C++也不错，通过特定的协议，JAVA和C++可方便的互相调用。
下面是我写的BBS，数据库处理部分用一个C++程序，对browse服务的是
java编写的java bean+jsp， java bean可调用 sbbs.cpp提供的服务。

browse =>; Tomcat =>; bbs_bean.java =>; sbbs.cpp =>; 数据库

/*
本程序为 BBS 的服务程序
客户端为 bbs_beam.java a
xlC -c -I../include svr1.cpp goddess.a stdclass.a
make -f proc.mk cppbuild EXE=tmp OBJS='tmp.o svr1.o goddess.a stdclass.a'
mv tmp sbbs
*/
#include <goddess.h>;
#include <string.h>;
#include <ctype.h>;
int New_Topic(TCallFace * ccf)
{
char user_name[100],subject_id[100],topic[1024],detail[8192],topic_id[100],detail_id[100];
char sqlcmd[4096];
TSQLCA dbio;
ccf->;GetParaValue("user_name",user_name);
ccf->;GetParaValue("subject_id",subject_id);
ccf->;GetParaValue("topic",topic);
ccf->;GetParaValue("detail",detail);
sprintf(sqlcmd,"update bbs_subject set topic_num=topic_num+1,record_num=record_num+1,"
"last_time='%s' where subject_id = %s",ITime.GetDateTime(),subject_id);
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
sprintf(sqlcmd,"select topic_num,record_num from bbs_subject where subject_id=%s",subject_id);
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
if (*dbio.mRowCount!=1)
{
dbio.Rollback();
return 0;
};
dbio.GetRes(0,topic_id);
dbio.GetRes(1,detail_id);
sprintf(sqlcmd,"insert into bbs_topic(subject_id,topic_id,topic,name,register_date,\
reply_num,last_time) values(%s,%s,'%s','%s','%s',0,'%s')",
subject_id,topic_id,topic,user_name,ITime.GetDateTime(),ITime.GetDateTime());
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
sprintf(sqlcmd,"insert into bbs_detail(subject_id,topic_id,detail_id,name,detail,\
register_date) values(%s,%s,%s,'%s','%s','%s')",
subject_id,topic_id,detail_id,user_name,detail,ITime.GetDateTime());
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
ccf->;ResetPara();
ccf->;PushPara("topic_id",topic_id);
dbio.Commit();
return 1;
}
int New_Detail(TCallFace * ccf)
{
char topic_id[30],subject_id[30],topic[1024],user_name[40],detail[8192],detail_id[30];
char sqlcmd[8192];
TSQLCA dbio;
ccf->;GetParaValue("user_name",user_name);
ccf->;GetParaValue("subject_id",subject_id);
ccf->;GetParaValue("topic_id",topic_id);
ccf->;GetParaValue("topic",topic);
ccf->;GetParaValue("detail",detail);
sprintf(sqlcmd,"update bbs_subject set record_num=record_num+1,last_time='%s' "
" where subject_id = %s",ITime.GetDateTime(),subject_id);
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
sprintf(sqlcmd,"select record_num from bbs_subject where subject_id=%s ",subject_id);
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
if (*dbio.mRowCount!=1)
{
dbio.Rollback();
return 0;
};
dbio.GetRes(0,detail_id);
sprintf(sqlcmd,"update bbs_topic set reply_num=reply_num+1,"
"last_time='%s' where subject_id = %s and topic_id=%s",
ITime.GetDateTime(),subject_id,topic_id);
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
sprintf(sqlcmd,"insert into bbs_detail(subject_id,topic_id,detail_id,name,detail,"
"register_date) values(%s,%s,%s,'%s','%s','%s')",
subject_id,topic_id,detail_id,user_name,detail,ITime.GetDateTime());
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
dbio.Commit();
return 1;
}
int New_Member(TCallFace * ccf)
{
char user_name[30],passwd[30],email[60],qq_number[100],home_page[200],sqlcmd[8192];
TSQLCA dbio;
ccf->;GetParaValue("name",user_name);
ccf->;GetParaValue("passwd",passwd);
ccf->;GetParaValue("email",email);
ccf->;GetParaValue("qq_number",qq_number);
ccf->;GetParaValue("home_page",home_page);
sprintf(sqlcmd,"insert into bbs_member(name,pwd,email,qq_number,home_page,register_date) values("
"'%s','%s','%s','%s','%s','%s')",
user_name,passwd,email,qq_number,home_page,ITime.GetDateTime());
dbio.ExecuteSql(sqlcmd);
if(dbio.HaveError())
{
dbio.Rollback();
return 0;
};
dbio.Commit();
return 1;
};
int NetRunSql(TCallFace * ccf)
{
char sqlcmd[8096];
char *pool;
int size;
TSQLCA dbio;
printf("begin to netrunsql\n");
ccf->;GetParaValue("sqlcmd",sqlcmd);
printf("get sql command: '%s'\n",sqlcmd);
dbio.ExecuteSql(sqlcmd);
ccf->;ResetPara();
pool = dbio.PackData(&size);
ccf->;PushPara("sqlpack",pool,'S',size);
if(pool!=NULL) IMem.Free(pool);
dbio.Commit();
return 1;
}
#include <itf_db.h>;
int AppStart()
{
ITF_SetBusinessType(11,"11-BBS服务程序");
if(!ITF_Initlize())
exit(0);
ITF_DefineFunction("new_topic", "创建一个话题",New_Topic);
ITF_DefineFunction("new_detail", "追贴",New_Detail);
ITF_DefineFunction("new_member", "创建一个用户",New_Member);
ITF_DefineFunction("NetRunSql", "单句执行",NetRunSql);
Use_Db_Oracle();
if(!DbConnect("bbs","bbs_db","dds"))
exit(0);
ITF_Execute();
return 1;
}
int main(int argc,char * argv[])
{
ITF_Link(AppStart);
}

复制代码

//javac -classpath "c:\javalib\j2ee.jar;." *.java
//javac *.java
package control;
import java.io.*;
import java.text.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import goddess.*;
import java.lang.*;
import java.util.*;
public class bbs_bean
{
String mName;
String mPwd;
TNCLink mLink;
TItf_Db mDbConn;
TSQLCA mDbio;
TCCFace mCcf;
protected String mAction;
protected HttpServletRequest mRequest;
protected HttpServletResponse mResponse;
protected Servlet mServlet;
protected HttpSession mSession;
protected boolean mSkipPageOutput;
public void setName(String name)
{
mName = name;
}
public void setPwd(String pwd)
{
mPwd = pwd;
}
/**执行操作**/
public void SetRequest (HttpServletRequest newRequest)
{mRequest = newRequest;}
public void SetResponse (HttpServletResponse newResponse)
{mResponse = newResponse;}
public void SetServlet (Servlet newServlet)
{mServlet = newServlet;}
public void SetSession(HttpServletRequest newRequest)
{mSession = newRequest.getSession(true);}
protected void Redirect (String redirectURL) throws java.io.IOException
{
mSkipPageOutput = true;
mResponse.sendRedirect(redirectURL);
}
public int Have_Logined()
{
if(mSession.getAttribute("usr_name")!=null)
return 1;
return 0;
};
static protected String GetGBKString(String val) throws IOException
{
String tmp_string = new String("（空）");
if(val == null || val.trim().equals(""))
return new String(tmp_string.getBytes("ISO-8859-1"),"GBK");
else
return new String(val.getBytes("ISO-8859-1"),"GBK");
}
public int Process_Login() throws java.io.IOException
{
int return_val;
String msg;
String query;
query = "select name from bbs_member where name='"+GetGBKString(mName)+"' and pwd='"+mPwd+"'";
mDbio.ExecuteSql(query);
if(mDbio.mRowCount<1)
{
Redirect("login.jsp");
return 1;
};
mSession.setAttribute("usr_name",GetGBKString(mName));
mSession.setAttribute("usr_pwd",mPwd);
Redirect("show_subject.jsp");
return 1;
}
public int Process_New_Member() throws java.io.IOException
{
String name,passwd,email,qq_number,home_page;
int []res=new int[1];
name=GetGBKString(mRequest.getParameter("name"));
passwd=mRequest.getParameter("passwd");
email=mRequest.getParameter("email");
qq_number=mRequest.getParameter("qq_number");
home_page=mRequest.getParameter("home_page");
mCcf.ResetPara();
mCcf.SetBusinessType(11);
mCcf.PushPara("name",name);
mCcf.PushPara("passwd",passwd);
mCcf.PushPara("email",email);
mCcf.PushPara("qq_number",qq_number);
mCcf.PushPara("home_page",home_page);
mCcf.RCall("new_member",res);
if(res[0]==1)
{
mSession.setAttribute("usr_name",mName);
mSession.setAttribute("usr_pwd",mPwd);
Redirect("show_subject.jsp");
}
else
Redirect("login.jsp");
return 1;
}
public int Process_New_Topic() throws java.io.IOException
{
String subject_id,topic,name,register_date,detail,topic_id,detail_id;
int []res=new int[1];
name=(String)mSession.getAttribute("usr_name");
subject_id=mRequest.getParameter("subject_id");
topic=GetGBKString(mRequest.getParameter("topic"));
detail=GetGBKString(mRequest.getParameter("detail"));
mCcf.ResetPara();
mCcf.SetBusinessType(11);
mCcf.PushPara("user_name",name);
mCcf.PushPara("subject_id",subject_id);
mCcf.PushPara("topic",topic);
mCcf.PushPara("detail",detail);
mCcf.RCall("new_topic",res);
topic_id=mCcf.GetParaValue("topic_id");
Redirect("show_topic.jsp?subject_id="+subject_id+"&max_id="+topic_id);
return 1;
}
public int Process_New_Detail() throws java.io.IOException
{
String topic_id,subject_id,topic,name,register_date,detail,detail_id;
int []res=new int[1];
subject_id=(String)mRequest.getParameter("subject_id");
topic_id=(String)mRequest.getParameter("topic_id");
mCcf.ResetPara();
mCcf.SetBusinessType(11);
mCcf.PushPara("user_name",(String)mSession.getAttribute("usr_name"));
mCcf.PushPara("subject_id",subject_id);
mCcf.PushPara("topic_id",topic_id);
mCcf.PushPara("topic",GetGBKString(mRequest.getParameter("topic")));
mCcf.PushPara("detail",GetGBKString(mRequest.getParameter("detail")));
mCcf.RCall("new_detail",res);
Redirect("show_detail.jsp?subject_id="+subject_id+"&topic_id="+topic_id);
return 1;
}
public int Do_Process()
{
int return_val;
String action;
int res=0;
try
{
action = mRequest.getParameter("action");
System.out.println("action from bbs_bead is:"+action);
if(action.equals("login"))
res=Process_Login();
if(action.equals("new_member"))
res=Process_New_Member();
if(action.equals("new_topic"))
res=Process_New_Topic();
if(action.equals("new_detail"))
res=Process_New_Detail();
} catch (Exception ignore) {};
return 1;
}
/////////////////////////////////////////////////////////////
public int Connect_Server()
{
mLink=new TNCLink();
mDbConn=new TItf_Db_Net(mLink,11);
mDbio=mDbConn.New_Tsqlca();
mCcf=new TCCFace(mLink);
return mLink.Connect("168.168.168.200",9810);
};
public void Disconnect()
{
mLink.Disconnect();
};
public TSQLCA Fetch_Subject() throws java.io.IOException
{
mDbio.ExecuteSql("select subject_id,subject,describe,topic_num,record_num,fmt_date(last_time) ftm,manager from bbs_subject order by subject_id");
return mDbio;
};
public String Get_Subject_Title() throws java.io.IOException
{
int topic_num,page_num,id;
String subject_id,subject="";
int record_parent_id;
String query;
subject_id = mRequest.getParameter("subject_id");
query = "select subject from bbs_subject where subject_id="+subject_id;
mDbio.ExecuteSql(query);
if(mDbio.mRowCount<1) return null;
subject=mDbio.GetRes(0);
return subject;
};
public String Get_Page_Url() throws java.io.IOException
{
int topic_num,page_num,id;
String subject_id,url="";
int record_parent_id;
String query;
subject_id = mRequest.getParameter("subject_id");
query = "select topic_num from bbs_subject where subject_id="+subject_id;
mDbio.ExecuteSql(query);
if(mDbio.mRowCount<1) return null;
topic_num=Integer.parseInt(mDbio.GetRes(0),10);
page_num=(topic_num+49)/50;
url="[";
for(id=1;id<=page_num;id++)
{
url+="<a href=show_topic.jsp?subject_id="+subject_id+"&max_id="+topic_num+">;";
url+= id +"</a>; ";
url+= " ";
topic_num-=50;
};
url+="]";
return url;
};
public TSQLCA Fetch_Topic() throws java.io.IOException
{
String subject_id,max_id;
int record_parent_id;
String query;
subject_id = mRequest.getParameter("subject_id");
max_id = mRequest.getParameter("max_id");
query = "select topic_id,topic,name,fmt_date(register_date) ft,reply_num from ";
query += "bbs_topic where subject_id="+subject_id+" and topic_id<="+max_id;
query += " and topic_id>;"+max_id+"-50 order by last_time desc";
mDbio.ExecuteSql(query);
return mDbio;
};
public String Get_Topic_Title() throws java.io.IOException
{
int return_val;
String topic_id,subject_id,title="";
int record_parent_id;
String query;
subject_id = mRequest.getParameter("subject_id");
topic_id = mRequest.getParameter("topic_id");
query = "select topic from bbs_topic where ";
query +="subject_id="+subject_id+" and topic_id="+topic_id;
System.out.println(query);
mDbio.ExecuteSql(query);
if(mDbio.mRowCount<1) return null;
title=mDbio.GetRes(0);
return title;
};
public TSQLCA Fetch_Detail() throws java.io.IOException
{
int return_val;
String topic_id,subject_id;
int record_parent_id;
String query;
subject_id = mRequest.getParameter("subject_id");
topic_id = mRequest.getParameter("topic_id");
query = "select detail_id,detail,name,fmt_date(register_date) ft from bbs_detail where ";
query +="subject_id="+subject_id+" and topic_id="+topic_id+" order by register_date ";
System.out.println(query);
mDbio.ExecuteSql(query);
return mDbio;
};
}

复制代码

作者: mengwg 时间: 2003-07-05 20:41
标题: c与c++区别讨论
干脆再贴一个 jsp

<%@ page import="java.lang.*"%>;
<%@ page import ="control.*"%>;
<%@ page import ="goddess.*"%>;
<%@ page contentType="text/html; charset=gb2312" %>;
<jsp:useBean id="_bbs_bean" class="control.bbs_bean" scope="session"/>;
<jsp:setProperty name="_bbs_bean" property="*"/>;
<% _bbs_bean.SetRequest(request);%>;
<% _bbs_bean.SetResponse(response);%>;
<% _bbs_bean.SetServlet(this);%>;
<% _bbs_bean.SetSession(request);%>;
<% _bbs_bean.Connect_Server();%>;
<html>;
<head>;
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">;
<title>;欢迎浏览论坛科目</title>;
<style type="text/css">;
#tt {text-align: center;font-family: 宋体;font-size: 11pt;color:white;background-color: "#828DA6"; }
#td {font-family: 宋体;font-size: 10pt;color:black;background-color: white;};
</style>;
</head>;
<body>;
<font color="Teal" size=4>;<i>;<strong>;<u>; Welcome to onlyit bbs </u>;</strong>;</i>;</font>;
<%if(_bbs_bean.Have_Logined()==0) { %>;
<FORM name=theForm action="act_jsp.jsp?action=login" method=post>;
用户名： <input type="text" name="name" size=10>;
密　码： <input type="password" name="pwd" size=8>;
<input type="submit" name="Submit" value="登录论坛" >;
<a href="new_member.jsp">;免费注册</a>;
<br>;<font size=2>;如果 www.onlyit.cn 无法登录，请用http://cwqu.3322.org/</font>;
</form>;
<% }; %>;
<hr>;
<table width="100%" cellspacing="0" cellpadding="0" border="1" align="center">;
<tr >;
<td id='tt' >;涉及内容</td>;
<td id='tt' >;主题数量</td>;
<td id='tt' >;贴子数量</td>;
<td id='tt' >;最后回复</td>;
<td id='tt' >;版主</td>;
</tr>;
<%
TSQLCA dbio;
int id;
dbio=_bbs_bean.Fetch_Subject();
for(id=0;id<dbio.mRowCount;id++)
{
out.println("<tr >;");
out.println("<td id='td'>; <a href='show_topic.jsp?subject_id="+dbio.GetRes(0)+"&max_id="+dbio.GetRes(3)+"'>;"+dbio.GetRes(1)+"</a>; <br>; &nbsp&nbsp&nbsp&nbsp"+dbio.GetRes(2)+"</td>;");
out.println("<td id='td'>;"+dbio.GetRes(3)+"</td>;");
out.println("<td id='td'>;"+dbio.GetRes(4)+"</td>;");
out.println("<td id='td'>;"+dbio.GetRes(5)+"</td>;");
out.println("<td id='td'>;"+dbio.GetRes(6)+"</td>;");
out.println("</tr>;");
dbio.Next();
};
%>;
</table>;
</body>;
</html>;
<% _bbs_bean.Disconnect();%>;

复制代码

作者: 无双 时间: 2003-07-05 20:50
标题: c与c++区别讨论
参考
想研究一下B/S结构

这份可以当个参考

作者: mengwg 时间: 2003-07-05 21:14
标题: c与c++区别讨论
源代码可在 http://www.onlyit.cn/ 下载区下载
bbs2.orient.zip
本站bbs源代码，jsp+java bean+goddess(无需jdbc)

作者: 无双 时间: 2003-07-05 23:02
标题: c与c++区别讨论
谢谢

作者: zhxlanjuan 时间: 2003-07-06 14:09
标题: c与c++区别讨论
确实是各种语言都有他的优缺点,关键是要看应用场合;

java的速度慢,我是比较有体会,我做过的通讯系统用c做的,一秒钟大概可以到1000条消息以上,而另外一个系统是用java做的,一秒钟大概只有30-50条这样,差别比较大;

但是用java的开发效率很高,有很多现成的类库可以使用,这是比较爽的一面;

作者: 无双 时间: 2003-07-06 18:45
标题: c与c++区别讨论
看需要什么样的开发了

如果是图形的话
那么C++BUILDER也有很多类库

如果只是算法的话那么也有STL可以用总的来说把一门语言用得精通了也是很方便的

作者: powerplane 时间: 2003-07-07 00:44
标题: c与c++区别讨论
python也很好

作者: 大菠萝 时间: 2003-07-07 09:10
标题: c与c++区别讨论
语言都好，看我们的应用场合和精通程度了。

java的速度慢,我是比较有体会,我做过的通讯系统用c做的,一秒钟大概可以到1000条消息以上,而另外一个系统是用java做的,一秒钟大概只有30-50条这样,差别比较大;

这个不是很相信，java能有这么差吗？？JBoss 可是用Java作的，我觉得十你的那个Java 系统的问题，不是Java语言的问题。

作者: jerryzheng 时间: 2003-07-09 13:15
标题: c与c++区别讨论
小弟刚入门，不过我知道java和c++的最大区别是，C++可以做出象传奇这样的网络游戏，而也能做出传奇的外挂，

作者: mushuang 时间: 2003-07-09 13:36
标题: c与c++区别讨论
c/c++一般用于开发系统程序

java开发界面程序

可以认为c++与操作系统结合紧密
这是它的优点也是缺点
优点是可以充分利用系统优势
缺点是移植到其它平台时会麻烦

作者: 惜过 时间: 2003-07-09 13:36
标题: c与c++区别讨论
我觉Ｃ＋＋里中包括Ｃ语言，它更那懂，不过要是搞软件开发的话，还是用Ｃ＋＋，方便多了，

作者: Dasn 时间: 2003-07-28 14:08
标题: c与c++区别讨论
C/C++;
菜刀/食品加工机；
做饭时喜欢用菜刀，因为砍的顺手了。呵呵~

作者: odin_free 时间: 2003-07-28 18:42
标题: c与c++区别讨论

原帖由 "Dasn" 发表：
C/C++;
菜刀/食品加工机；
做饭时喜欢用菜刀，因为砍的顺手了。呵呵~

这个比喻在c陷阱与缺陷里看过

菜刀就是菜刀，他的优点就是方便

要是想安全，改造之后就成了食品加工厂

做菜应该用菜刀，当然用食品加工厂切菜也是行的，但是不见得就那么方便

作者: stonemason 时间: 2003-07-29 15:04
标题: c与c++区别讨论
所谓善书不择笔，善将不择兵。只要认同OOP,汇编也可面向对象(有牛人为证，不过记不大清楚了)。OOP是一种新思想，而C++给与了语言上的直接支持，用c++或者java什么的，看您老方便了。可以说C++的出现是一种必然：C语言应用如此成功而且广泛，给它扩展OOP的成分不是很自然的吗? c++扩展自C似乎无须争论了吧？那么，扩展部分不就是两者不同之处么？
呵呵，无知言论，大家指正。

作者: 无双 时间: 2003-07-29 17:36
标题: c与c++区别讨论
不是很认同

虽然每个语言都可以实现OOP
但是实现的复杂度呢

C++中比C增加了很多内容如类多态继承等
如果C也可以实现OOP 那么就没有必要创建C++
甚至不用开发什么objc(面向对象的C)语言了

所以我想语言决定了在它上面的应用和编程思想

作者: Aprils 时间: 2004-03-11 10:09
标题: c与c++区别讨论
C语言也可面向对象编程，有本《ANSI C 面向对象编程》的书不错。
比如：
struct B
{
  int data;
  void (*p)();
};

struct D
{
  struct B * base; // B是D的基类
  int dData;
  void (*g)();
}

作者: 美丽人生 时间: 2004-08-21 16:13
标题: c与c++区别讨论
[quote]原帖由 "JohnBull"]C++的目标是成为一个OO语言,至少这一点是不争的事实,可以他在OO得并不彻底(毕竟它还有main函数啊).[/quote 发表：

脑袋不是一般的秀豆，我就写过没有"main"的C++程序，而且还是WINDOWS的驱动程序。
你可以看看MAIN是怎么定义的，你把他写到类里面也成，不过是他的名字增加了类名及：：，然后呢，你把写定义成static，类外的都是static，类里的不定义的话叫this call，是要带this指针的，因为这个main是给系统调用的，系统当然不知道this是多少（事实上这里没有也用不着），所以不能成为this call，使用static定义，

最后，编译器将程序入口定义在main，你要使用加了类名的main作为入口，你还得在编译参数中设置你的程序入口，不过这个不晓得是否所有的C++编译器都支持。

还有人说编译器是先将C++翻成C再生成机器码，你管得着人家怎么生成，只要你好写，他给你编译得更有效就Ok，你去看看编译原理，人家编译本来就是一步一步转换嘛。人家当初C先生成ASM优化再生成机器码，你不说C又跟ASM一样了？

你再看看JAVA，还不是要生成一个中间码，莫非JAVA又只当他的中间码了？

我很喜欢C++，是因为他可以用OO的思想，而且得到很好的实现，更重要的是，他适合我做的工作！

说一个语言的好坏不能跟其他语言简单的比较。其实本也没有好坏，只看你用得合不合适了，比如汇编强大吧，你拿来给我写个WEB服务出来嘛，一点也不好写对吧。

JAVA好用吧，你给我写个PCI网卡驱动用用，写不出来吧！

其实就是选择最合适的工具罢了！

作者: zerglot 时间: 2004-10-15 16:03
标题: c与c++区别讨论
我要补课

作者: ecloud 时间: 2004-10-15 21:22
标题: c与c++区别讨论
面向对象的话,Java比起Python还是要差一点的
不过Python是一个怪胎，它太灵活了，可以按照面向结构的方式编码也可以按照面向对象的方式编码，也可以按照过程的方式或者脚本语言的方式编码
随便一个C,Java,汇编或者perl，都可以翻译成一个结构差不多的相应的Python程序来
除了不支持LISP那种古怪的面向函数的编码风格以外，Python唯一的缺点就在于性能了

作者: windflowers1976 时间: 2004-10-15 21:50
标题: c与c++区别讨论
呵呵，讨论的最佳结果不是争出输赢，而是明白道理或方法。现在项目的流行趋势就是用Java Gui/ Jsp (J2EE)作为业务表示层。底层的数据层用C/C++ ＋中间件＋数据库。所以，没有最佳的工具，只有最佳的组合。
当然，客户看到的都是花花绿绿的界面，呵呵。

欢迎光临 Chinaunix (http://bbs.chinaunix.net/)