pointer as data members

i have to create a class of student with the following data members,

Code:

class student
{
      char *name;
      int age;
      int *regNum;
      int *address;
      int cgp;

i dun know how to intialize them in argumentless constructor ,, and set the values in argument constructor and copy constructor.
can anybody help??

The only meaningful value you can initialize them with without any arguments to the constructor, is 0 for the pointers. Use an initialization list for that.

I would rather set pointers to NULL.

Originally Posted by Elysia

I would rather set pointers to NULL.

Stroustrup says you should use 0.

Stroustrup: C++ Style and Technique FAQ

I use NULL in C and 0 in C++.

He does not say you should use 0. He says he prefers to avoid macros, hence uses 0.
I don't agree. NULL is supposed to be a null pointer constant and thus should be used to initialize pointers (but nowhere else).
NULL shall eventually be replaced with nullptr, too.

Code:

 student()
   {
     name=new char(' ');
     age=0;
     regno=new int(0);
     address=new int(0);
     cgp=0;
   }

  student( char* nm, int ag, int* rn, int *ad, int cg)
   {
     strcpy(name,nm);
     age=age;
     regno=rn;
     address=ad;
     cgp=cg;
   }

ohk above is the parameterless and with parameter constructor,,
Can anbody help mee with the copy constructor??

I am guessing that your motivation for having pointer member variables is that you want to have dynamically allocated arrays. If so, I suggest that you ditch the pointers in favour of:

Code:

#include <string>
#include <vector>

class student
{
public:
    // ...
private:
    std::string name;
    std::vector<int> regNum;
    std::vector<int> address;
    int age;
    int cgp;
};

Now, if it is the case that due to artificial assignment requirements you are not allowed to use std::string and std::vector, then you should create two more classes: a string class and an integer array class. You would then substitute them for std::string and std::vector<int>.

The reason why I suggest this is that it can be rather challenging to manually manage memory correctly for more than one dynamically allocated array simultaneously.

As for what you have now:

Code:

name=new char(' ');

This looks wrong. It dynamically allocates a single char by itself, but if you wanted to do that, then you might as well just have a single char as a member instead of having a pointer. You should use new[] instead of new (and thus use delete[] instead of delete).

Code:

#include<iostream.h>
#include<conio.h>
#include<string.h>
class student
  {	char *name;
	int   age;
	int  *regno;
	int  *address;
	int   cgp;
private:
  student()
   {
    name=new char[10];
    age=0;
    regno=new int(0);
    address=new int(0);
    cgp=0;
   }

  student( char* nm, int ag, int* rn, int *ad, int cg)
   {
    strcpy(name,nm);
    age=ag;
    regno=rn;
    address=ad;
    cgp=cg;
   }
  
  ~student()
  {
	  delete name;
	  delete regno;
	  delete address;
  }


   student(const student &k)
   {
    name=k.name;
    age=k.age;
    regno=k.regno;
    address=k.address;
    cgp=k.cgp;
   }

   void setname()
   {
   cin>>name;
   }

   char* getname()
   {
   return name;
   }

   void print()
   {
   cout<<name<<endl;
   cout<<age<<endl;
   cout<<regno<<endl;
   cout<<cgp<<endl;
   }
  };

int main()
{
clrscr();
student a;
student b;
a.setname();
a.getname();
a.print();
b.print();
getch();
return 0;
}

Student::student() is not accesible
student::~student() is not accessible
student::setname(), getname() not accessible

They are declared with private access instead of public access.

You have other problems in the code, as well...

Code:

  student( char* nm, int ag, int* rn, int *ad, int cg)
   {
    strcpy(name,nm);
    age=ag;
    regno=rn;
    address=ad;
    cgp=cg;
}

strcpy is unsafe - you do not know how long the string you try to copy is. It may cause buffer overruns. That is why you should use std::string.
For rn and ad (extremely poor names, btw, you should make them more descriptive), get have a memory leak. The reason is that you allocate memory, but never free it before replacing the pointer's value with something else.
Even worse is that you simply copy the pointers over and never change the object you copy from.
As it stands, when either object goes out of scope, it will delete its data. But then, when the second object goes out of scope, it will try to delete the data that has already been freed, thus causing undefined behavior.
I suggest you avoid pointers.

Also, setname is wrong. It should not ask for name; setname is a function that names the object. Hence, it should take its new as a parameter and let the caller be responsible for attaining the name and passing it along.

oops sorry