我有一个脚本给我错误403 Forbidden error,它只是另一个脚本的副本,但不同之处在于它们都使用另一个mysql类来访问数据库.
我的整个项目已经完成,这是最后一个文件,因此我不想再为单个文件完成整个工作.
服务器日志显示客户端被服务器配置拒绝:
我应该寻找什么？
我尝试过以下方法:
但是,index.php效果很好.
我正在努力克服以下情况.
给定存储在NTFS卷上的目录,其中:
(或者简而言之,所有管理员都被锁定在文件夹之外)
但!
(或者简而言之,我有权修复DACL /所有者)
我对以下代码应该没有问题:
WindowsIdentity privilegedUser = System.Security.Principal.WindowsIdentity.GetCurrent();
// I cannot use File.GetAccessControl() as I get access denied
// (working as intended! I have no access to read the ACL!)
// so I have to write a new ACL:
FileSecurity acl = new FileSecurity();
acl.SetOwner(admin.User);
acl.AddAccessRule(new FileSystemAccessRule(privilegedUser.User, FileSystemRights.FullControl, AccessControlType.Allow));
File.SetAccessControl("c:\\path\\to\\broken", acl);
但是,SetAccessControl调用会抛出UnauthorizedAccessException.当我改变它只调整所有者时,同样的事情发生.当我只尝试调整DACL时,同样的事情.
我通过在Process Explorer中检查生成的进程并验证Administrators组是否设置为"Owner"而不是"Disabled"来验证问题不是UAC.我应该拥有执行此操作所需的所有权限(备份操作员在面对管理员时应该是无关紧要的,但我将其添加进行测试) - 但它只是继续拒绝访问权限.
相关的technet文档:http://technet.microsoft.com/en-us/library/cc783530%28WS.10%29.aspx
没有经验shared_ptr<>我想知道以下是否是一个合适的用例,以及返回shared_ptr<>给用户是否是一个好主意.
我有一个结构图,节点之间有多个连接.在遍历图形期间,为每个节点分配一个值(从连接的节点计算),并且我希望用户能够轻松地访问该值.整个事情看起来(强烈简化)像这样:
class Pool;
class Node {
public:
typedef std::tr1::shared_ptr<Node> Ptr;
...
void compute_dependencies() {
...
// calls Pool to get a new Node instance
dependencies_.push_back(Pool::create_node(...));
...
}
// evaluate the current node
void evaluate() { /* use dependencies_ */ };
double value() const { if(evaluated) return value_; };
private:
std::vector<Node::Ptr> dependencies_; // vector<Node*> better?
dbl value_;
}
// Pool creates and owns all nodes
class Pool {
public:
static const Node::Ptr create_node(...); // create a …我是C++ 11的一些代码.我有
class X { /* */ };
class A {
std::vector<X*> va_x;
};
class B {
std::vector<X*> vb_x;
std::vector<A> vb_a;
};
我的类A中的"va_x"的X*s指向我的类B中"vb_x"的X*s指向的对象.
现在我想使用智能指针.对我来说,似乎很清楚,B类拥有X*指向的对象的所有权(特别是因为我的A实例属于B)
所以我应该在B中使用unique_ptr for X:
class B {
std::vector<unique_ptr<X>> vb_x;
std::vector<A> vb_a;
};
我的问题是,我应该为A班做些什么？我应该保留原始指针吗？通过这样做,在我的单元测试中,我必须承认它导致尴尬的事情(imo),例如(不要担心封装,这不是重点):
unique_ptr<X> x(new X());
A a;
a.va_x.push_back(&(*x)); //awkward, but what else can I do?
A.vb_a.push_back(a); //ok
B.vb_x.push_back(move(x)); //ok
我刚刚写了一个小的Rust程序,它计算Fibonacci数并记住计算.它有效,但我有点困惑为什么,特别是递归调用.(它也可能不是惯用的.)
这是程序:
use std::collections::HashMap;
fn main() {
let n = 42; // hardcoded for simplicity
let mut cache = HashMap::new();
let answer = fib(n, &mut cache);
println!("fib of {} is {}", n, answer);
}
fn fib(n: i32, cache: &mut HashMap<i32,i32>) -> i32 {
if cache.contains_key(&n) {
return cache[&n];
} else {
if n < 1 { panic!("must be >= 1") }
let answer = if n == 1 {
0
} else if n == 2 {
1
} else …许多用于std::unique_ptr管理类依赖项所有权的示例如下所示:
class Parent
{
public:
Parent(Child&& child) :
_child(std::make_unique<Child>(std::move(child))){}
private:
std::unique_ptr<Child> _child;
};
我的问题是,标记该_child成员是否const有任何意想不到的副作用？(除了是保证reset(),release()等不能被称为_child).
我问,因为我还没有在一个例子中看到它,不知道这是故意还是仅仅是为了简洁/普遍.
从这里获取示例片段：以下内容无法编译
fn foobar<F>(mut f: F)
where F: FnMut(i32) -> i32
{
println!("{}", f(f(2)));
// error: cannot borrow `f` as mutable more than once at a time
}
fn main() {
foobar(|x| x * 2);
}
但这确实
fn foobar<F>(mut f: F)
where F: FnMut(i32) -> i32
{
let tmp = f(2);
println!("{}", f(tmp));
}
fn main() {
foobar(|x| x * 2);
}
我不明白为什么第一个片段是非法的：它实际上与第二个片段相同，只是写得更简洁。更具体地说，为什么必须f(f(2))可变地借用f两次？它可以简单地借用内部f来计算 的值f(2)，然后借用外部f并将其应用于该值。
编译以下使用运算符重载的Rust代码
use std::ops::{Add};
#[derive(Show)]
struct Point {
x: int,
y: int
}
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point {
Point {x: self.x + other.x, y: self.y + other.y}
}
}
fn main() {
let p: Point = Point {x: 1, y: 0};
let pp = p + p;
}
由于p的所有权导致编译器错误:
<anon>:21:18: 21:19 error: use of moved value: `p`
<anon>:21 let pp = p + p;
^
<anon>:21:14: 21:15 note: `p` moved …fn main() {
let strA = "a";
let result;
{
let strB = "abc";
result = longest(strA, strB); // Will return strB
}
println!("The longest string is {}", result); // result now point to strB!!
}
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
'a将得到的混凝土的寿命等于该较小的寿命的x和y
那么为什么strB现在在其范围之外可见？
我发现它令人困惑&(*&a)并且&{*&a}行为不同。
详细地说，以下代码编译失败：
struct CanNotCopy;
fn main(){
let a = CanNotCopy;
&{*&a};
let c = a;
}
并编译了以下代码：
struct CanNotCopy;
fn main(){
let a = CanNotCopy;
&(*&a); // or &*&a;
let c = a;
}
上述代码之间的语义区别是什么？
究竟哪些语言结构会导致所有权的转移？