我有一个有很多孩子的家长班.Parent类中的每个函数都是纯函数,即函数没有父实现,但子函数有自己的实现.无需在那里发布代码 - 标准的东西.
我不希望人们从任何地方创建父类的直接实例化.通过让虚拟功能保持纯净,我可以安全地防范这种情况.
我的问题:根据用户的输入(字符串),我想实例化其中一个孩子.我只知道运行时哪一个.我的(不正确的？)想法是以下编译好并且正常工作,直到我将代码放入函数并返回父级.
这样可行:
Parent* parent;
if(user_input == "A") {
Child1 child1;
parent = &child1;
}
else if(user_input == "B") {
Child2 child2;
parent = &child2;
}
但这不起作用:
Parent* foo(string user_input) {
Parent* parent;
if(user_input == "A") {
Child1 child1;
parent = &child1;
}
else if(user_input == "B") {
Child2 child2;
parent = &child2;
}
return parent;
}
当我说它不起作用我的意思是,它编译但是当我这样做时我得到一个分段错误:
Parent* parent = foo(user_input);
parent->some_child_function(); // segmentation error here
我确定这是一个关于我没有完全理解指针的愚蠢/简单的问题.在阅读了书籍/文章中的所有关于它们之后,我仍然不知道我做错了什么......它可能是一个单行修复？
谢谢 :).
我必须在C++中定义一个函数,它生成一个类Foo的向量并返回它.
我可以用不同的方式定义它,它们都是完全相同的:
C样式参数传递:
void generateFooVector(vector<Foo> * result)
{
for (int i = 0; i < 100; i++)
{
Foo f = Foo();
result->push_back(f);
}
}
int main()
{
vector<Foo> result;
generateFooVector(&result);
}
参考传球:
void generateFooVector(vector<Foo> & result)
{
for (int i = 0; i < 100; i++)
{
Foo f = Foo();
result->push_back(f);
}
}
int main()
{
vector<Foo> result;
generateFooVector(result);
}
实例化向量并返回指针:
vector<Foo> * generateFooVector()
{
vector<Foo> * result = new vector<Foo>();
for (int i = 0; i < …这里我只想定义一个函数,它返回矩阵的乘法,N任意,我想生成一个带new命令的矩阵.当我执行该函数时,我得到错误:
Segmentation fault (core dumped)
每当我分配值给C我有这个错误时,有人能告诉我发生了什么以及如何解决它？
int **multiply(int **A, int **B, int N){
int **C = new int*[N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++)
C[i][j] = C[i][j] + A[i][k] * B[k][j];
}
}
return (C);
}
可能重复:
类型名称后的括号是否与new有所不同？
以下代码执行哪些操作:
Test *t1 = new Test; // there is no () after new Test;
如果有用户声明默认构造函数？
那这个呢:
Test *t2 = new Test(); // there is () after new Test;
构造函数的执行分两个阶段完成:
初始化阶段
正文执行阶段,由构造函数体内的所有语句组成.请注意,类型的数据成员始终在初始化阶段初始化,无论该成员是否在构造函数初始化列表中显式初始化.初始化发生在构造函数体的任何语句执行之前.
让我们考虑一种通过构造函数初始化类学生实例的方法-
Student(string &fn, string &ln, int i, int y = Freshman)
: first_name(fn)
, last_name(ln)
, id(i)
, year(y)
{}
这是另一种,但"低效"和"不优雅"的做法 -
Student(string &fn, string &ln, int i, int y = Freshman)
{
first_name = fn;
last_name = ln;
id = i;
year = y;
}
新代码中的此构造函数(上面的代码)分配类Student的成员.它没有明确初始化它们.是否存在显式初始值设定项,即使在执行构造函数之前,也会初始化first_name和last_name成员.此构造函数隐式使用默认字符串构造函数来初始化first_name和last_name成员.执行构造函数的主体时,first_name和last_name成员已具有值.这些值将被构造函数体内的赋值覆盖.
所以,这意味着当执行到达构造函数的开始括号时,这就是条件 -
现在,很明显,在构造函数的主体中对四个变量中的每个变量进行了赋值.
我对这件事的理解是对的吗？我不知何故觉得我错过了什么. …
class A
{
public:
int get(void){return stuff;}
void set(int s){stuff = s;}
private:
int stuff;
};
int _tmain(int argc, _TCHAR* argv[])
{
A a;
A b();
A* ap = new A;
A* bp = new A();
}
我不知道main()中的四行之间的区别是什么,以及我可能使用哪一种与另一种(除了在堆栈或堆上)之间的区别.我注意到第四行实际上将"stuff"初始化为0,而其他行则没有.第二行似乎根本不是什么,这看起来很奇怪.
问题:每条线的权衡/含义是什么(在main()中)？是否使用parens对我来说很困惑.
这里已经讨论了这个问题[链接] new []是否在C++中调用默认构造函数？
作为一个初学者和一个自学者,将赞赏积极的评论,请不要将其概括为广泛,狭隘等
当我们使用new []时,每个元素都由默认构造函数初始化,除非类型是内置类型.默认情况下,内置类型保持单一化.
这里有人说默认构造函数初始化对象是什么意思？是不是每个对象现在都将键初始化为零(由默认构造函数),因为当我打印p [2] .key时这是真的？
如何检查默认构造函数是否初始化数组或不是int数组,它无法访问main中的成员键？
另外(i)打印垃圾值,但(ii)打印0;
class People
{
public:
int key;
People()
{
key=0;
}
};
int main()
{
int count=5;
People *p=new People[count];
cout<< p[2].key;
// int *arr=new int[count]; ...(i)
//cout<<*(arr+2);
//int *arr=new int[count](); ... (ii)
//cout<<*(arr+2)<<endl;
return 0;
}
可能重复:
类型名称后的括号是否与new有所不同？
我相信这个问题已经被问到了,但我找不到快速搜索.
Foo ob* = new Foo;
Foo ob* = new Foo();
这两种在C++中创建对象的方法有区别吗？如果没有,那么其中一个被认为是不好的做法？每个编译器都会对它进行相同的处理吗？