类定义时如果没有定义带参数的构造函数，对象初始化能不能这样写： A a(1,2);

类中默认构造函数是无参数的，你只能 A a； 如果你想要带参数 A a(1，2 )；
你就要自己写一个带参数的构造函数 如 class A {
private:
int x;
char y;
public:
A(int a, char b)
{x= a；y=b};
};
定义对象的时候，会根据你参数个数，自动调用匹配的构造函数来初始化对象的。
你定义A a;就调用默认无参构造，定义 A a(3,‘c’)； 成员变量x和y就是你传入的参数 3和'c'了
希望对你有帮助

#include
#include
#include
using namespace std;
template/// 这个是一个模板类，
class A
{
T para1;
T para2;
public:
static int shot_a;
static int shot_b;
A(float p1,float p2)
{
para1=p1/100;
para2=p2/150;
};
A(){};// 默认的构造函数

void score(T c);
float getpara1()
{
float x=float(rand()%100)/10+para1-5;
return x;
};
float getpara2()
{
float x=float(rand()%100)/10+para2-5;
return x;
};
}; ///*不要改变这段程序里面的类型（T和确知的类型）
template
int A::shot_a=0;
template
int A::shot_b=0;

int ram(float p,unsigned n)
{
int m=0;
int w=int(p*10000); //*10000容易引发错误，最好是定义为double型
for (int i=0;i if (rand()%10000 return m;
}

template // 在外部定义成员
void A::score(T c) //其实你的这里也定义错误了，因为你看，如果你的T的实例时int的话，那么你的c 是一个int型，但是你看c.para，说明c必须是一个结构体，共用体，等
{
int pa=(para1-c.para2/8)/40;
int pb=(c.para1-para2/8)/40;
shot_a=ram(pa,92);
shot_b=ram(pb,92);
}

// template// 你这里要实现是定义一个对象名的模板? 好像是没法使用吧，因为你写入一个常理不合理，但是在main中你又必须初始化这个，所以貌似不可以对象模板
// A a1(float,float); //此时要与类模板的参数相对应，不能写入常量，类模板的实例 <类模板名> <<数据类型表》》 <<对象名列标>> 入Stack ba; int是实例化的，而ba是实例化int是的对象
// template //**********
// A a2(float,float); // 主要是没有意义的，因为就是定义了但是在下面也是要重新定义的，因为模板不允许有常量形参

void main()
{
srand(time(0));
//但是这里你错了，因为你没有定义类模板的实例 <类模板名> <<数据类型表》》 <<对象名列标>>
A list;// 这里的list调用了默认的构造函数，你没定义，
// 其实就是这么说吧，被T修饰的地方，如果你定义了A(int)那么所有被T修饰的地方都被int代换，，，，，明白不？这个是实质，可能说的不对，但是有助你理解
A a1(2,3);
A a2(3,3);

cout<<"比赛结果"< // 验证你的

cout<<"比赛结果"<cout<<"比赛结果"<}

//不知道我的解释你懂不，，嘻嘻，我也在学，，这一部分，恩，你大概是钻了牛角尖了，自己看看书，看清了概念就会明白的，
//
下面是我的一个实验的程序，，你看一下，

// 这个是一个栈类，能够实现对int float ,double ,的进入栈测试，，再实现char 型，和string型的操作
#include
#include "string"
using namespace std;
template
class Stack
{
int size;// 栈的大小
int top;//定义头标志
T* tack;// 定义一个栈的结构，动态分配空间的，
public:
Stack(int=10);// 初始化成10个空间
bool push(const T& );
bool pop(T& );
bool isEmpty()const // 这里是判断的是top==-1而不是top=-1不是赋值的过程所以错误了，
bool isFull()const // 所以在修改错误的时很必须好好的看明白
~Stack()
// 定义析构函数的情况
};
// 下面是在类外定义的情况
// template
// <返回类型> 类模板名 <类型名表>::成员函数( 形式参数表)

template
Stack::Stack(int s)
{
size=s>0?s:10;
top=-1;
tack=new T[size];
}
template
bool Stack::push(const T& pushvalue)
{
if(!isFull())
{
tack[++top]=pushvalue; // 因为这里是0开始的，，，所以先要++
return true; // bool类型，返回值为TRUE或是failed，为了用了看是否满足下一步，但是这里这个值也是可以手动赋的，所以比我一起的方好用
}
return false;
}
template
bool Stack::pop(T &popvalue)
{
if(!isEmpty())
{
popvalue=tack[top--];
return true;
}
return false;
};

void main()
{
Stack doublestack(5);
double f=1.0;
cout<<"开始为，双精度类型入栈"< while(doublestack.push(f))
{
f++;
}
cout<<"栈满了"< cout<<"双精度开始出栈"< while(doublestack.pop(f))
{
cout< }

Stack intstack;
int a=22;
cout<while(intstack.push(a))
{ a+=2;
}
cout<<"出栈"<while(intstack.pop(a))
{ cout<}
cout<Stack charstack;
char ch='a';
while(charstack.push(ch))
{ ch+=2;
}
cout<<"字符出栈"<while(charstack.pop(ch))
{ cout<}
cout<Stack ststack;
string st="wosh";
while(ststack.push(st))
{ st;
}
cout<<"出栈"<while(ststack.pop(st))
{ cout<}

cout<<"\n 元素全部出栈"<
}

很明显不能。因为A a(1, 2)调用的就是带两个参数的构造函数。

还满意回答呢 明显错了 当你定义了带参数的构造函数 默认构造函数就不再自动生成了