我对以下代码有一个奇怪的情况.请帮我澄清一下.
class B
{
public:
B();
virtual void print(int data=10)
{
cout << endl << "B--data=" << data;
}
};
class D:public B
{
public:
D();
void print(int data=20)
{
cout << endl << "D--data=" << data;
}
};
int main()
{
B *bp = new D();
bp->print();
return 0;
}
关于我预期的输出
[ D--data=20 ]
但实际上它是
[ D--data=10 ]
请帮忙.这对你来说似乎很明显,但我不了解内部机制.
我对以下情况感到困惑
const char c = 'C';
char * p = const_cast<char *>(&c);
*p = 'K';
cout << " c = " << c << endl;
cout << " *p = " << *p << endl;
printf("c's address : %u\n", &c);
printf("P is pointing to : %u\n", p);
在执行时输出如下
c = C
*p = K
c's address : 3221180271
P is pointing to : 3221180271
在这里,我可以观察到'&c'和'p'在内存中具有相同的地址.
那么'p'能够存储与'c'不同的值的隐藏机制是什么,而两者在内存中共享相同的地址空间？
我已经看到构造函数,复制构造函数,析构函数和赋值运算符保存在典型的单一类中的私有范围内.例如
class CMySingleton
{
public:
static CMySingleton& Instance()
{
static CMySingleton singleton;
return singleton;
}
private:
CMySingleton() {} // Private constructor
~CMySingleton() {}
CMySingleton(const CMySingleton&); // Prevent copy-construction
CMySingleton& operator=(const CMySingleton&); // Prevent assignment
};
现在,我的问题是
为什么要将析构函数和赋值运算符保留在私有范围内呢？这是强制性的吗？
公共析构函数是否会破坏单例类的任何属性？因为我们的对象构造受到限制所以不会有不必要的破坏.
我可以理解私有赋值运算符可以阻止自我赋值,但是除了额外的运行时间之外,公共赋值运算符是否还会受到伤害？
需要帮助以了解以下行为.
static int a;
int b[a];
for(int i=0; i<10; i++)
b[i] = i+1;
for(int i=0; i<10; i++)
cout << " " << b[i];
输出为$> 1 2 3 4 5 6 7 8 8 10
但是,如果我将变量'a'声明为auto [like int a],那么它会在运行时崩溃,这很明显.但为什么它与静态一起工作.此外,如果我运行循环更多的时间(高于10)它崩溃.我做了12并且它崩溃了.此外,输出8在8和10之间而不是9,这是异常的.请帮忙.....
#include <iostream>
using namespace std;
class B
{
B();
public:
virtual void print()=0;
};
void B::print()
{
cout << "B::print";
}
int main()
{
B *bp;
bp->B::print(); /* Type-A works fine */
bp->print(); /* Type-B segmentation fault */
return 0;
}
在上面的代码中,我试图通过'bp'调用纯虚函数.现在在main函数中有两种类型的调用(Type-A,Type-B).我的问题是为什么A有效,但B没有.此外,为什么编译器允许在不创建对象的情况下调用非静态函数.
int main()
{
myClass obj;
.... /* doing things */
....
delete &obj; /* illegal */
}
让我们假设myClass是一个适当的C++类,其中包含所有内容.现在,我知道这是非法的,这个程序会在运行时崩溃.第一件事就是代码试图删除一个堆栈对象,然后在范围完成之后它再次被破坏.我想知道这种非法行动的内部情况.即删除会发生什么,它会调用析构函数吗？对你来说可能看起来很疯狂,但请帮助我理解.
对于谁知道背景魔法可能是显而易见的,但我无法理解下面的代码如何提供正确的输出.我预计运行时错误.请帮忙.
class a
{
public:
void print()
{
cout<<"Hello\n"<<endl;
int d = 100;
cout<<d<<endl;
}
int val;
};
int main()
{
a* ptr;
ptr->print();
return SUCCESS;
}
输出如下:
Hello
100
我需要在perl脚本中获得18位Julian Timestamp.有人可以帮助我吗？但是我已经编写了一个子程序来实现这一点,但它对我来说并不好看,因为它总是给我一个以6个零结尾的数字.请帮助获得一个正确的18位J时间戳.
sub GetJulianTimestamp()
{
my $t = `perl -e 'print time, "\n"'`;
return (($t * 1000000 ) + 210866803200000000);
}