1.怎么写构造函数

构造函数一般是用来进行初试化的，看你需要对哪些属性进行初始化

#include

#include

class student

{

public:

char name[10];

float score;

student(char[],float)；//这里形式参数就是你要初试化的变量的类型。

~student();

};

student::student(char temp[10],float score1)

{

strcpy(name,temp);

score=score1;

coutcout

}

student::~student()

{

cout}

void main()

{

student stu("sunhong",99);

}

2.JAVA的构造函数是怎么写的

JAVA的构造函数是：SetLocal EnableDelayedExpansion

set classpath=.

for %%c in (lib*.jar) do set classpath=!classpath!;%%c

set classpath=%classpath%;./classes;

java com.ham.server.Server。

1、无参构造方法

无参构造方法又分为隐式无参构造方法和显示无参构造方法。

隐式无参构造方法

在定义类的时候，如果没有给类定义一个构造方法，Java编译器在编译时会默认提供一个隐式的构造方法，它没有任何参数，并且有一个空的方法体。例如，Person类中隐含一个无参构造方法，在main方法中可以通过new关键字来调用此默认的构造方法，代码如下：

2、显式无参构造方法

隐式无参构造方法是由系统提供的，无法修改其内容。但有时需要在调用这个构造方法时初始化类成员属性或执行一些操作，要实现这个需求，就需要为它定义一个显式无参构造方法，修改上述代码如下：

3、显示有参构造方法

构造并初始化对象是构造方法的作用，所以有时需要给这个方法传入一些参数，定义一个显示的有参构造方法。例如：

3.c++派生类的构造函数怎么写

先写基类的，构造函数，然后在写子类的

比如

class a

{

private:

int k;

public:

a(int i){k=i;}

};

class bac:public a

{

private:

int c;

public:

bac(int m,int n):a(m) // 这里利用初始化参数表来赋值

{

c=n;

}

};

4.请问正确的拷贝构造函数该怎样写

#include

using namespace std;

class my

{

public:

my() : p(0) {} // 初始化p，因为~中判断后进行delete

~my(){if(p)delete p;}

my(const my& s){

p = new int(*p)； // 不能直接对指针进行赋值，这里p是new了一个int，值为*p

}

void set(int x){

if (p) delete p； // 检测p是否为0，不为0时需要delete。

p=new int(x);}

void print(){coutprivate:

int *p;

};

void main()

{

my obj1;

obj1.set(3);

my obj2(obj1);

obj2.print();

}

你的问题是，拷贝构造函数中，只是简单的给成员指针变量进行赋值，这样在对象进行析构的时候，多次对delete同一指针。.要不加上引用计数也行啊.

5.vector c++构造函数怎么写

构造函数有多个

explicit Vector(int initsize = 0); //explicit是为了防止让一个实参的构造函数发生隐式转换

Vector(int initsize, T value);

Vector(iterator b, iterator e)； //接受两个迭代器创建拷贝的构造函数 ，这里的迭代器的创建是指针，见上面

Vector(std::initializer_list<T> l);

Vector(const Vector &rhs);

template <typename T>

Vector<T>::Vector(int initsize = 0) :thesize(initsize), thecapacity(initsize + SPARE_CAPACITY)

{

elem = new T[thecapacity];

assert(elem != NULL)； //存储分配失败则退出；

}

template<typename T>

Vector<T>::Vector(std::initializer_list<T> l) //列表初始化，新标准

{

thesize = l.size();

thecapacity = thesize + SPARE_CAPACITY;

elem = new T[thecapacity];

assert(elem != NULL);

int i = 0;

auto beg = l.begin();

while (beg != l.end() && i != thesize)

{

elem[i] = *beg;

++i;

++beg;

}

}

template <typename T>

Vector<T>::Vector(int initsize, T value) :thesize(initsize), thecapacity(initsize + SPARE_CAPACITY)

{

elem = new T[thecapacity];

assert(elem != NULL)； //存储分配失败则退出；

for (int i = 0; i != thesize; ++i)

elem[i] = value;

}

template <typename T>

Vector<T>::Vector(iterator b, iterator e)

{

thesize = e - b;

thecapacity = thesize + SPARE_CAPACITY;

elem = new T[thecapacity];

assert(elem != NULL);

for (int i = 0; b != e&&i != thesize; ++i)

{

elem[i] = *b;

++b;

}

}

//拷贝构造函数，接受一个容器为另一个容器的拷贝（深拷贝）

template <typename T>

Vector<T>::Vector(const Vector &rhs)

{

thesize = rhs.thesize;

thecapacity = rhs.thecapacity;

elem = new T[thecapacity];

assert(elem != NULL);

for (int i = 0; i != thesize; ++i)

elem[i] = rhs.elem[i];

}