我遇到了以下代码,我无法理解它的含义:
typedef int INT;
5 .INT::~INT();
注意:数字5和小数之间有一个空格.
问题:
1.有人可以解释上面两条线的确切含义吗？2.如果没有typedef,为什么它不起作用？它背后的任何原因？5 .int::~int()抛出错误.
有人能给我一个现实的例子,其中O(N*N)算法比O(N)某些算法更快N>10.
编辑:我认为这个问题因过于笼统而被搁置.但我确实只有一般性问题.没有其他方式可以以不同的方式提出这个问题.
在以下程序中，我打算通过将char* line内容从一个对象复制到另一个对象strcpy。但是，当程序结束时，析构函数obj2可以正常工作，但会obj导致崩溃。gdb显示line两个对象的不同地址。
class MyClass {
public:
char *line;
MyClass() {
line = 0;
}
MyClass(const char *s) {
line = new char[strlen(s)+1];
strcpy(line, s);
}
~MyClass() {
delete[] line;
line = 0;
}
MyClass &operator=(const MyClass &other) {
delete[] line;
line = new char[other.len()+1];
strcpy(line, other.line);
return *this;
}
int len(void) const {return strlen(line);}
};
int main() {
MyClass obj("obj");
MyClass obj2 = obj;
我很难理解stroustrup对于必须遇到什么困难的解释,如果运算符重载'.' 曾经被允许.
请参阅Bjarne Stroustrup的这句话:
运营商.(dot)原则上可以使用与 - >相同的技术重载.但是,这样做会导致对操作是否意味着对象重载的问题.或者提到的对象.例如:
class Y {
public:
void f();
// ...
};
class X { // assume that you can overload .
Y* p;
Y& operator.() { return *p; }
void f();
// ...
};
void g(X& x)
{
x.f(); // X::f or Y::f or error?
}
在上面的例子中,为什么在执行时会有任何混淆x.f() ？
Y& operator.() { return *p; }
这是我的想法:
Y& operator.()( return *p; }不应该被称为obivous和直觉吗？*p指向Y类型的对象,因此Y::f()应该最终调用(不是X::f())我在stroustup的解释中缺少什么？为什么不直截了当？
我遇到了一个套接字编程教程，其中引用了它
“指向结构sockaddr_in的指针可以转换为指向结构sockaddr的指针，反之亦然 ”
我不明白如何将sockaddr_in强制转换为sockaddr。将Big类型的指针转换为Small类型的指针应具有UD行为。
struct sockaddr {
unsigned short sa_family; // address family, AF_xxx
char sa_data[14]; // 14 bytes of protocol address
};
struct sockaddr_in {
short int sin_family; // Address family, AF_INET
unsigned short int sin_port; // Port number
struct in_addr sin_addr; // Internet address
unsigned char sin_zero[8]; // Same size as struct sockaddr
};
如何不能强制转换？将它们相互投射是不安全的吗？
如果我有一个A类只有两个整数，而B类则只有4个整数。如果我有一个类型为B的指针并将其强制转换为类型A，那么请确保我可以获取前两个元素。但是，如果类A具有首先声明的2个字符和之后声明的2个整数，则指针将无法正确获取值，因为在这种情况下，对象布局将有所不同。
编辑1：
class Anu
{
public:
char a;
int b;
Anu()
{
a='a';
}
};
class Anurag
{ …strcmp比较字符串内容，因此优先于if (str1 == str2)比较字符串的基地址。
如果是这样，为什么if下面的 C 代码会满足条件：
char *p2="sample1";
char* str[2]={"sample1","sample2"};
if(p2==str[0])
{
printf("if condition satisfied\n");
}
广东发展局：
(gdb) p p2
$1 = 0x4005f8 "sample1"
(gdb) p str[0]
$2 = 0x4005f8 "sample1"
(gdb) p &p2
$3 = (char **) 0x7fffffffdb38
(gdb) p &str[0]
$4 = (char **) 0x7fffffffdb20
(gdb) p *p2
$5 = 115 's'
到底是什么0x4005f8以及如何打印它？
这是什么真正的意思是“专业化的函数模板不参与重载决议的一部分。只有基本模板被认为是”
我用它的专用版本编写了一个简单的模板函数，可以看到它被调用了：
// Base template
template <typename T>
T max(T a, T b) {
std::cout << "Base Template" << std::endl;
return (a>b) ? a : b;
}
// Specialization for int
template<>
int max<int>(int a, int b) {
std::cout << "int specialization" << std::endl;
return (a>b) ? a : b;
}
max(2,3);// prints "int specialization"
查看与此概念相关的其他 StackOverflow，我发现了另一篇文章，以证明专业化不参与重载他展示了以下示例，其中未调用专用版本，但我仍然不确定为什么没有调用它. 但除此之外，在这个例子中，参数没有变量名，但该部分仍然没有编译或运行时错误(char const* const&)
template<typename T>
void f(T const&)
{
std::cout<<std::endl<<"Base Template for f() called\n";
}
template<>
void f<char const * const …为什么我的内部功能无法使用引用打印值？
sub fun {
$ref = @_;
print "\n Inside the function $ref->[1] \n";
}
my @arr=(2,3,4);
fun (\@arr);
my $ref2 = \@arr;
print "\n$ref2->[1]\n";
我得到的输出是:
Inside the function
3
我有一个 linux 文件，其内容如下：
hey this
is just
sample file
我想要 ：
1. 根据第二个单词对三行进行排序，因此输出应为：
sample file
is just
hey this
2. 根据第二行的第二个字符对三行进行排序，因此输出为：
hey this
sample file
is just
无论如何我可以在命令行上运行 perl/unix 命令（使用管道无关紧要）？
在下面的例子中,我最后调用了pthread_join()两个线程(在打印总和之前).即使预期总和应为0,它也会打印任何值.我知道,如果我pthread_join(id1,NULL)在创建第二个线程之前就做了,那么它可以正常工作(确实如此),但我不明白为什么在我最后为两个线程调用join时它不应该工作.
因为只有在两个线程必须完全执行完毕后才打印sum.因此,在执行第一个线程之后,它必须已将2000000添加到变量sum中,并且第二个线程必须从总和中减去2000000应该为0
long long sum=0;
void* counting_thread(void* arg)
{
int offset = *(int*) arg;
for(int i=0;i<2000000;i++)
{
sum=sum+offset;
}
pthread_exit(NULL);
}
int main(void)
{
pthread_t id1;
int offset1 = 1;
pthread_create(&id1,NULL,counting_thread,&offset1);
pthread_t id2;
int offset2 = -1;
pthread_create(&id2,NULL,counting_thread,&offset2);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
cout<<sum;
}