小编Abr*_*rar的帖子

在React的官方文档中提到 -

如果您熟悉React类生命周期方法,则可以将useEffect Hook视为componentDidMount,componentDidUpdate和componentWillUnmount的组合.

我的问题是 - 我们如何componentWillMount()在钩子中使用lifecyle方法？

我正在试验React中的新Hook功能.考虑到我有以下两个组件(使用React Hooks) -

const HookComponent = () => {
  const [username, setUsername] = useState('Abrar');
  const [count, setState] = useState();
  const handleChange = (e) => {
    setUsername(e.target.value);
  }

  return (
    <div>
      <input name="userName" value={username} onChange={handleChange}/>
      <p>{username}</p>
      <p>From HookComponent: {count}</p>
    </div>
  )
}


const HookComponent2 = () => {
  const [count, setCount] = useState(999);
  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
}

钩权利要求来解决的共享部件之间的有状态逻辑的问题,但我发现之间的状态HookComponent和HookComponent2不共享.例如,countin 的改变HookComponent2 …

我对 Python 比较陌生。我正在研究不相交集，并按如下方式实现：

class DisjointSet:
    def __init__(self, vertices, parent):
        self.vertices = vertices
        self.parent = parent

    def find(self, item):
        if self.parent[item] == item:
            return item
        else:
            return self.find(self.parent[item])

    def union(self, set1, set2):
        self.parent[set1] = set2

现在在驱动程序代码中：

def main():
    vertices = ['a', 'b', 'c', 'd', 'e', 'h', 'i']
    parent = {}

    for v in vertices:
        parent[v] = v

    ds = DisjointSet(vertices, parent)
    print("Print all vertices in genesis: ")
    ds.union('b', 'd')

    ds.union('h', 'b')
    print(ds.find('h')) # prints d (OK)
    ds.union('h', 'i')
    print(ds.find('i')) # prints …

我正在学习汇编语言(特定于x86).我已经理解 SAL并且 SHL以类似的方式工作(清除lsb并将msb携带到CF)从这里开始在80x86中SHL和SAL之间的区别.

考虑到SHR并且SAR不以类似的方式操作(后者保持msb不变).

我想大概有一个明确的概念,为什么的功能移位算术右移 SAR定义不同右移 SHR,但在同一时间SHL ,并 SAL保持与类似的功能？

我如何查询关系,仍然包括没有关系的模型？有两种型号

• 商店

• 产品

码

// Store
public function products() {
   $this->belongsToMany('App\Store');
}

// Product
public function stores() {
   $this->belongsToMany('App\Product');
}

和一个用于连接它们的数据透视表product_store.有些商店没有任何产品.我如何查询所有产品,甚至是那些不属于任何商店的产品,例如:

Product::where('store.id', '=', 1)->get()

这就是我目前的做法.

Product::whereHas('stores', function($query) {
    $query->where('id', '=', $store_id);
});

但随着laravel文档提到这个

检索至少有一个商店的所有产品

我对C++世界比较陌生.我知道std::cout用于C++中的控制台输出.但请考虑C中的以下代码:

#include<stdio.h>

int main(){
    double dNum=99.6678;
    printf("%.02lf",dNum);
    //output: 99.67
 return 0;
}

如何cout在C++中使用最多2位小数的双重类型值实现类似的格式化？

我知道C++与C向后兼容.但是如果有的话,C++中是否有printf()等价,那么它定义在哪里？

我知道我们不允许仅基于返回类型重载函数.假设我有两个函数double convert(string num)并int convert(string num) 考虑以下示例代码:

double convert(string num){
    stringstream ss;
    double d_num;
    ss<<num;
    ss>>d_num;
    return d_num;
}

int convert(string num){
    int i_num;
    /*.....
   same as previous
   .....
   */
   return i_num;
}

在main()中:

int main(){
    string st="09122321";
    double d1=convert(st);
    int i1=convert(st);

}

虽然我重载函数只在返回类型上有所不同但是因为我根据它们的返回类型将它们分配给数据类型不是我应该得到转换string num后的double d1和int i1 ？

现在我得到的错误类似于:

错误:新声明'int convert(std :: string)'| 错误:模糊旧声明'double convert(std :: string)'|

convert()如果我希望通过重载函数让它具有不同的返回类型,我将如何完成工作？

考虑在 React 中定义函数式组件的以下三个地方 -

1. 在类内部（在 render 方法之外）
2. 在类内（在 render 方法内）
3. 课外

在下面的示例代码，funcComponent1，funcComponent2和funcComponent3在三个不同的位置限定。我如何考虑何时在这 3 个位置中的任何一个定义功能组件？

import React, { Component } from 'react';


const FuncComponent1 = (props) => {
  return (
    <p>{props.name}</p>
  )
}

class TestComponent extends Component {

  constructor(props){
    super(props);
    this.state = {
      name: "JavaScript"
    }
  }


  FuncComponent2 = (text) => {
    return (
      <p>{text}, {this.state.name}</p>
    )
  }


  render(){

    const FuncComponent3 = (props) => {
      return (
        <p>{props.text}, {this.state.name}</p>
      )
    }

    return (
      <div>
        <FuncComponent1 …

我有两个类下面的示例代码程序员和CSstudent哪里

CSstudent:public Programmer

为这两个类定义了析构函数:

class Programmer{
           .........
            public:
               ~Programmer(){
                 cout<<"A Programmer obj destroyed";       
        }
      }

class CSstudent:public Programmer{
           .........
       public:
        ~CSstudent(){
          cout<<"CSstudent obj destroyed";
      }
         }

现在在main()中:

int main(){
    CSstudent cs1;

    /* call to CSstudent member functions by invoking the cs1 object
      ........... */

    cout<<cs1.getName()<<cs1.getUni()<<cs1.getLang()<<endl;
}

程序运行后,我得到以下内容: CSstudent obj销毁程序员obj被破坏

我知道析构函数不是继承的,当对象超出范围时会调用析构函数.我初始化了一个CSstudent对象然后为什么调用Programmer类的析构函数？

我希望这个输出: CSstudent obj被破坏了

我有以下课程:

class PhoneCall{
private:
    string number;
public:
    /*some code here */
};

现在,我宣布一个函数(不是朋友到PhoneCall,做一些具体的操作和返回)PhoneCall对象

PhoneCall callOperation()

另一个将PhoneCall对象作为参数

void userCall(PhoneCall obj)

我期待它不起作用,除非明确宣布为该类的朋友.

即使他们不是PhoneCall类的朋友,这些功能为什么以及如何工作？

类的友元函数在类的范围之外定义,但它有权访问类的所有私有和受保护成员 http://www.tutorialspoint.com/cplusplus/cpp_friend_functions.htm