Thread: dont konw what to do next.

all those problems you mentioned occur because stdlib.h was not included. You are hung up on that one issue. Assume all the correct header files are included, I can't imagine any other objections to typcasting. I always include these three header files in every *.c program, so I never experience the problem you are describing about malloc() not being prototyped.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

But why should you when it's not necessary and simply introduces another point of failure? The reasons for not casting malloc may be weak according to you, but can you give us a single good reason for why the casting approach is favourable?

Originally Posted by ^xor

but can you give us a single good reason for why the casting approach is favourable?

Portability to C++. Have you ever tried to port a C program to C++? If not then you should try it some time -- it gets pretty painful and ugly fixing up all C's shortcomings, like lack of typcasting. Just change the file extension from *.c to *.cpp and compile with a c++ compiler. You will find out very quickly the porting problems.

Other than that, its really just personal preference. I wouldn't think of changing existing C code unless actually porting to c++ because it isn't worth the effort.

Originally Posted by Narf

Yes! Finally we're on the same page. If you do everything right, there's nothing wrong with typecasting. But since nobody is perfect,

I am

Originally Posted by Narf

Even when all you need is stddef.h?

Yes. I don't recall writing a *.c file that only needed stddef.h. Most (if not all) use something from all three headers. 25 years ago I would have given more thought to it because of the amount of time to compile the program on that speedy 1.2 MG CPU computer with 64K memory, 2 single-sided floppy drives an no hard drive. But today compile time is not an issue on most modern computers.

Originally Posted by Salem

> Portability to C++. Have you ever tried to port a C program to C++?
And if a simple cast of malloc made all valid C programs valid C++ programs, then you might have a point. But it isn't.

Yes, I know there are several (many?) other differences too. Typcasting functinos that return void* is just one of them.

Originally Posted by Salem

Writing code which attempts to be compatible with multiple languages (why stop at C++, why not make it compilable with fortran while you're at it (yes, people do this for sport)) simply results in code which is neither good C nor good C++.

I am not concerned with other languages. C programs that need to be ported to fortran, cobol, C#, or a host of other languages will probably requires a (nearly) complete rewrite anyway. Only portability between C and C++ is the issue.

Originally Posted by Salem

In fact, I think I'll stick to using 'new' and 'class' as perfectly valid 'C' variable names thank you very much.

I would probably do that too, but only after the code can be cleanly compiled with 0 errors and 0 warnings.

Originally Posted by Salem

Why stop at 3? why not include all the standard headers (oh wait, I mentioned that already).

LOL! I take it you have never used VC++ 6.0/7.0 to compile a MS-Windows application ? just take a look at the contents of stdafx.h!

just take a look at the contents of stdafx.h!

Code:

#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers

#include <windows.h>

Wow, that was heavy! Regardless, unchecking the "use precompiled headers" box is the first thing I do in any MSVC++ project

Here is mine (after I added some to it. The ones in RED are the ones I added. Everything else was added by VC++ 6.0 project generator.

Code:

// stdafx.h : include file for standard system include files,
//      or project specific include files that are used frequently,
//      but are changed infrequently

#if !defined(AFX_STDAFX_H__470832EA_892F_487D_A270_5735AB3AB775__INCLUDED_)
#define AFX_STDAFX_H__470832EA_892F_487D_A270_5735AB3AB775__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define STRICT
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0400
#endif
#define _ATL_APARTMENT_THREADED
#include <afxdisp.h>


#include <atlbase.h>

// I added these myself
#include <winsock.h>
#include <sys\types.h>
#include <sys\stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <errno.h>
#include <share.h>
#include <time.h>
#include <string>
#include <vector>
#include <algorithm>
//#include <vector>
#include <list>
#include <fstream>
#include "ctpublic.h"
#include <cstypes.h>
using namespace std;

//You may derive a class from CComModule and use it if you want to override
//something, but do not change the name of _Module

#define VERSION		"2.08.04"

class CServiceModule : public CComModule
{
public:
	HRESULT RegisterServer(BOOL bRegTypeLib, BOOL bService);
	HRESULT UnregisterServer();
	void Init(_ATL_OBJMAP_ENTRY* p, HINSTANCE h, UINT nServiceNameID, const GUID* plibid = NULL);
    void Start();
	void ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv);
    void Handler(DWORD dwOpcode);
    void Run();
    BOOL IsInstalled();
    BOOL Install();
    BOOL Uninstall();
	LONG Unlock();
	void LogEvent(LPCTSTR pszFormat, ...);
    void SetServiceStatus(DWORD dwState);
    void SetupAsLocalServer();

//Implementation
public:
	static HANDLE m_hChangePasswordThread;
	static DWORD  m_dwChangePasswordID;
private:
	static void WINAPI _ServiceMain(DWORD dwArgc, LPTSTR* lpszArgv);
    static void WINAPI _Handler(DWORD dwOpcode);
// data members
public:
    TCHAR m_szServiceName[256];
    TCHAR m_szDisplayName[256];
    SERVICE_STATUS_HANDLE m_hServiceStatus;
    SERVICE_STATUS m_status;
	DWORD dwThreadID;
	BOOL m_bService;

private:
	void InitGatesIniFile(void);

	string m_targetPath;
	string m_server;
	string m_database;
	BOOL	m_rgates;
	long	m_loginSequence;
	HANDLE	m_userLock;
	string	m_timeHost;



};

extern CServiceModule _Module;
#include <atlcom.h>
#include <comdef.h>


#ifndef DEBUG_NEW
#define DEBUG_NEW new
#endif


//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__470832EA_892F_487D_A270_5735AB3AB775__INCLUDED)

Originally Posted by itsme86

This is just ludicrous.

Sorry if I am pi$$ing anybody off. This whole discussing started because (I think) the OP posted one little line of code that typecast the return value of malloc. malloc() itself is not the only problem -- every function that returns void* has the same problem whether it is a function in standard C library or one you write yourself. All I intended to say was there is nothing at all wrong with typcasting it, nor is there anything wrong with NOT typcasting it. -- while others disagreeded and said it should never be done!

Originally Posted by itsme86

I'm just tired of hearing the same argument over and over and over again. .

So don't read it.