C++模板的一些基础知识

一.函数模板

可看出就是将函数返回类型和形参类型去掉。

1.代码1

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;template<typename T>
void swap_(T& a, T& b ){T temp = a;a = b;b = temp;
}
int main()
{//1.自动类型推导 必须要一致的数据类型才可用int a1 = 10, b1 = 20;cout<<a1<<" "<<b1<<endl;swap_(a1, b1);cout<<a1<<" "<<b1<<endl;float a2 = 10.01, b2 = 20.55;cout<<a2<<" "<<b2<<endl;swap_(a2, b2);cout<<a2<<" "<<b2<<endl;//2.显示指定类型swap_<int>(a1, b1);cout<<a1<<" "<<b1<<endl;swap_<float>(a2, b2);cout<<a2<<" "<<b2<<endl;return 0;
}

有两种使用方式，一个是自动类型推导(必须要一致的数据类型才可用)，一个是显示指定类型。

2.代码2

将类型作为参数,用template修饰函数模板,解决不同类型函数但实现逻辑一样的问题

#include <iostream>
using namespace std;template <typename T>//函数模板
void display(T a)
{cout<<"a:"<<a<<endl;cout<<"======="<<endl;
}template <typename T,typename S>//函数模板
void display(T t, S s)
{   cout<<"t:"<<t<<endl;cout<<"s:"<<s<<endl;cout<<"======="<<endl;
}template <typename T,int KSize>//函数模板
void display(T a)
{for (int i=0;i<KSize;i++){cout<<"a:"<<a<<endl;}}int main()
{   display<int>(10);//模板函数display<double>(10.89);//模板函数display<int,float>(11,12.11);//模板函数display<int, 5>(11);return 0;
}

3.代码3

选择排序，降序排序

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;template<typename T>
void swap_(T& a, T& b){T temp = a;a = b;b = temp;
}//从大到小排序
template<typename T>
void sort_(T& arr){int n = sizeof(arr) / sizeof(arr[0]);for(int i = 0; i < n; i++){int index = i;for(int j = i + 1; j < n; j++){if(arr[index] < arr[j]){index = j;}}if(index != i){swap_(arr[index], arr[i]);}}
}
template <typename T>
void printArr(T& arr){int n = sizeof(arr) / sizeof(arr[0]);for(int i = 0; i < n; i++ ){cout<<arr[i]<<" ";}cout<<endl;
}
int main()
{
//    test06();char charArr[] =  "bdfdsskn";sort_(charArr);printArr(charArr);int intArr[] =  {6, 7, 4, 6, 8, 2, 3, 7};sort_(intArr);printArr(intArr);return 0;
}

4.普通函数和模板函数的调用规则

4.1如果函数模板和普通函数都可以调用，优先调用普通函数

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//
void myPrint(int a, int b){cout<<"调用的普通函数"<<endl;
}template <typename T>
void myPrint(T a, T b){cout<<"调用的函数模板"<<endl;
}
void test06(){int a = 10, b = 20;//如果函数模板和普通函数都可以调用，优先调用普通函数myPrint(a, b);
}
int main()
{test06();return 0;
}

4.2通过空模板参数列表，强制调用函数模板

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//
void myPrint(int a, int b){cout<<"调用的普通函数"<<endl;
}template <typename T>
void myPrint(T a, T b){cout<<"调用的函数模板"<<endl;
}
void test06(){int a = 10, b = 20;// 通过空模板参数列表，强制调用函数模板myPrint<>(a, b);
}
int main()
{test06();return 0;
}

4.3重载函数模板

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//
void myPrint(int a, int b){cout<<"调用的普通函数"<<endl;
}template <typename T>
void myPrint(T a, T b){cout<<"调用的函数模板"<<endl;
}template <typename T>
void myPrint(T a, T b, T c){cout<<"调用的重载函数模板"<<endl;
}
void test06(){int a = 10, b = 20;// 通过 空模板参数列表，强制调用模板函数myPrint<>(a, b);myPrint<>(a, b, 100);
}
int main()
{test06();return 0;
}

4.4 如果函数模板能够产生更好的匹配，优先使用函数模板

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//
void myPrint(int a, int b){cout<<"调用的普通函数"<<endl;cout<<"a:"<<a<<endl;cout<<"b:"<<b<<endl;
}template <typename T>
void myPrint(T a, T b){cout<<"调用的函数模板"<<endl;cout<<"a:"<<a<<endl;cout<<"b:"<<b<<endl;
}template <typename T>
void myPrint(T a, T b, T c){cout<<"调用的重载函数模板"<<endl;cout<<"a:"<<a<<endl;cout<<"b:"<<b<<endl;cout<<"c:"<<c<<endl;
}
void test06(){int a = 10, b = 20;char c1 = 'a';char c2 = 'b';// 优先将T推导为char 类型myPrint(c1, c2);
}
int main()
{test06();return 0;
}

可看出优先将T转换成char,而不是将char字符一个一个转换成int类型。 

二.类模板

类模板语法和函数模板语法很接近,都是先声明模板出来。

与函数模板差异

1.代码1:

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;template <class NameType, class AgeType>
class Person{
public:Person(NameType name, AgeType age){this->m_Name = name;this->m_Age = age;}void showPerson(){cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;}NameType m_Name;AgeType m_Age;
};void test06(){Person<string, int> p1("lining", 13);p1.showPerson();
}
int main()
{test06();return 0;
}

 

MyArray.h

#ifndef MYARRAY_H
#define MYARRAY_H
#include <iostream>
using namespace std;template <typename T, int KSize, int KVal>//T就是要定义的类型class MyArray
{public:MyArray();~MyArray(){delete []m_pArr;m_pArr=NULL;};void display();private:T *m_pArr;
};template <typename T,int KSize, int KVal>//函数定义时 一定要写
MyArray<T, KSize, KVal>::MyArray()
{m_pArr = new T[KSize];for (int i=0;i<KSize;i++){m_pArr[i] = KVal;}
}template <typename T,int KSize, int KVal>//函数定义时 一定要写
void MyArray<T, KSize, KVal>::display()
{for (int i=0;i<KSize;i++){cout<<"m_pArr[i]:"<<m_pArr[i]<<endl;}
}#endif

demo.cpp

#include <iostream>
#include <string>
#include "MyArray.h"
using namespace std;int main()
{   MyArray<int, 5, 6> arr;//每个元素都是6共5个元素的数组arr.display();return 0;
}

​

2.与函数模板差异

1.类模板没有自动推导方式

2.类模板中的参数列表可以有默认类型

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;
//类模板中的参数列表可以有默认类型
template <class NameType, class AgeType = int>
class Person{
public:Person(NameType name, AgeType age){this->m_Name = name;this->m_Age = age;}void showPerson(){cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;}NameType m_Name;AgeType m_Age;
};void test06(){
//   Person p1("lining", 13); //错误的
//   Person<string, int> p2("lining", 13);Person<string> p2("lining", 13); //有默认类型所以这里可以省去intp2.showPerson();
}
int main()
{test06();return 0;
}

3.类模板中成员函数和普通类成员函数创建方式

因为不知道是啥类型, 类模板中的成员函数在调用时才创建

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;
//类模板中的成员函数在调用时才创建 (因为不知道是啥类型)
//普通类中的成员函数一开始就创建
class Person1{
public:void showPerson1(){cout<<"showPerson1()"<<endl;}
};class Person2{
public:void showPerson2(){cout<<"showPerson2()"<<endl;}
};
template<class T>
class Myclass{
public:T obj;//类模板中的成员函数void func1(){obj.showPerson1();}void func2(){obj.showPerson2();}
};
void test06(){Myclass<Person1> m;m.func1();m.func1();
}int main()
{test06();return 0;
}

4.类模板对象做函数参数

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;
//类模板对象做函数参数
template<class T1, class T2>
class Person{
public:Person(T1 name, T2 age){this->m_Name = name;this->m_Age = age;}void showPerson(){cout<< "姓名: " << this->m_Name <<" 年龄: "<< this->m_Age <<endl;}T1 m_Name;T2 m_Age;
};//1.指定传入类型 (最常用)
void printPerson1(Person<string, int>&p){p.showPerson();
}
//2.参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>&p){p.showPerson();cout<<"T1类型: "<<typeid(T1).name()<<endl;cout<<"T2类型: "<<typeid(T2).name()<<endl;
}
//3.整个类模板化
template<class T>
void printPerson3(T &p){p.showPerson();cout<<"T类型: "<<typeid(T).name()<<endl;
}
void test06(){Person<string, int>p("limin", 100);printPerson1(p);printPerson2(p);printPerson3(p);
}int main()
{test06();return 0;
}

5.类模板与继承

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;template<class T>
class Base{
public:T m;
};
//class Son1:public Base{ //错误的，必须要知道父类中的T类型,才能继承给子类
class Son1:public Base<int>{};
template<class T1, class T2>
class Son2:public Base<T2>{ //如果想灵活指定父类中的T类型，子类也需要变类模板
public:Son2(){cout<<" T1类型: "<<typeid(T1).name()<<endl;cout<<" T2类型: "<<typeid(T2).name()<<endl;}T1 obj;
};void test06(){Son1 s1;Son2<int, char> s2;
}int main()
{test06();return 0;
}

6.类模板成员函数类外实现

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//类模板成员函数类外实现
template<class T1, class T2>
class Person{
public:Person(T1 name, T2 age);//类内实现构造函数
//    Person(T1 name, T2 age){
//        this->m_Name = name;
//        this->m_Age = age;
//    }
//    void showPerson(){
//        cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
//    }void showPerson();T1 m_Name;T2 m_Age;
};
//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){this->m_Name = name;this->m_Age = age;
}
//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
}
void test06(){Person<string, int>p("limin", 100);p.showPerson();
}int main()
{test06();return 0;
}

7.类模板类分文件编写

7.1.第一种方式：因为类模板成员函数一开始是不会创建的，所以包含.h头文件不会创建类模板成员函数，导致链接阶段无法找到。而改为#include .cpp就可以看见.h成员函数和实现方式.

demo.cpp

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
//#include "Person.h" //错误不能调用
#include "Person.cpp" //改为.cpp文件就行
//#include "Person.hpp" //改为.hpp文件就行 里面包含函数声明与实现
using namespace std;void test06(){Person<string, int>p("limin", 100);p.showPerson();
}int main()
{test06();return 0;
}

Person.h

#pragma once //防止头文件重复包含
#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//类模板成员函数类外实现
template<class T1, class T2>
class Person{
public:Person(T1 name, T2 age);void showPerson();T1 m_Name;T2 m_Age;
};

Person.cpp

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
#include "Person.h"
using namespace std;
//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){this->m_Name = name;this->m_Age = age;
}
//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.4.1)
project(Infantry)
add_definitions(-std=c++11)
set(CMAKE_BUILD_TYPE Debug)
set(SRC_LIST demo.cpp Person.cpp Person.h)
#set(SRC_LIST demo.cpp Person.hpp)
add_executable(demo ${SRC_LIST})

7.2函数声明和实现都在.hpp。

Person.hpp 

#pragma once //防止头文件重复包含
#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//类模板成员函数类外实现
template<class T1, class T2>
class Person{
public:Person(T1 name, T2 age);void showPerson();T1 m_Name;T2 m_Age;
};
//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){this->m_Name = name;this->m_Age = age;
}
//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
}

demo.cpp 

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
//#include "Person.h" //错误不能调用
//#include "Person.cpp" //改为.cpp文件就行
#include "Person.hpp" //改为.hpp文件就行 里面包含函数声明与实现
using namespace std;void test06(){Person<string, int>p("limin", 100);p.showPerson();
}int main()
{test06();return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.4.1)
project(Infantry)
add_definitions(-std=c++11)
set(CMAKE_BUILD_TYPE Debug)
#set(SRC_LIST demo.cpp Person.cpp Person.h)
set(SRC_LIST demo.cpp Person.hpp)
add_executable(demo ${SRC_LIST})

8.类模板配合友元函数的类内和类外实现

8.1.全局函数类内实现

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;template<class T1, class T2>
class Person{//全局函数 类内实现friend void printPerson(Person<T1, T2> p){cout<<" 姓名: "<<p.m_Name<< " 年龄: " <<p.m_Age<<endl;}
public:Person(T1 name, T2 age){this->m_Name = name;this->m_Age = age;}
//    void showPerson(){
//        cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
//    }
private:T1 m_Name;T2 m_Age;
};
void test06(){//全局函数类内实现的测试Person<string, int>p("limin", 100);printPerson(p);
}int main()
{test06();return 0;
}

8.2 全局函数类外实现

如果全局函数是类外实现的话 需要编译器提前知道这个函数的存在

 

9.案例

MyClass.hpp

#pragma once //防止头文件重复包含
#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;//类模板成员函数类外实现
template<class T>
class MyArray{
public://有参构造MyArray(int capacity){cout<<"调用构造函数"<<endl;this->m_capacity = capacity;this->m_size = 0;this->pAddress = new T[this->m_capacity]; //开辟堆区空间}//拷贝构造函数MyArray(const MyArray<T>& arr){cout<<"调用拷贝构造函数"<<endl;this->m_capacity = arr.m_capacity;this->m_size = arr.m_size;this->pAddress = new T[arr.m_capacity];//深拷贝//将arr中的数据拷贝过来for(int i=0; i<this->m_size; i++){this->pAddress[i] = arr.pAddress[i];}}//尾插法void PushBack(const T& value){//先判断是否等于大小if(this->m_capacity == this->m_size){return;}this->pAddress[this->m_size] = value; //尾插法this->m_size++; //更新数组大小}//尾删法void PopBack(){//让用户访问不了最后一个元素if(this->m_size == 0){return;}this->m_size--; //更新数组大小}//通过下标方式访问数组中元素T& operator[](int index){return this->pAddress[index];}//返回数组容量int getCapacity(){return this->m_capacity;}//返回数组大小int getSize(){return this->m_size;}//operator= 也是防止浅拷贝MyArray& operator=(const MyArray<T>& arr){cout<<"调用operator= 函数"<<endl;//先判断原来堆区是否与数据，如果有先释放if(this->pAddress != NULL){delete []this->pAddress;this->pAddress = NULL;this->m_capacity = 0;this->m_size = 0;}//深拷贝this->m_capacity = arr.m_capacity;this->m_size = arr.m_size;this->pAddress = new T[arr.m_capacity];//深拷贝//将arr中的数据拷贝过来for(int i=0; i<this->m_size; i++){this->pAddress[i] = arr.pAddress[i];}return *this;}virtual ~MyArray(){cout<<"调用析构函数"<<endl;if(this->pAddress != NULL){delete []this->pAddress;this->pAddress = NULL;}}
private:int m_capacity;int m_size;T* pAddress; //指针指向堆区开辟的真实数组
};

demo.cpp

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
#include "MyClass.hpp"
using namespace std;void test06(){MyArray<int> arr1(20);MyArray<int> arr2(arr1);MyArray<int> arr3(10);arr3 = arr1;for(int i=0; i<5; i++){arr1.PushBack(i + 10);}cout<<" ==before arr1.getCapacity(): "<<arr1.getCapacity()<<endl;cout<<" ==before arr1.getSize(): "<<arr1.getSize()<<endl;for(int i=0; i<arr1.getSize(); i++){cout<<"before arr1[i]: " <<arr1[i]<<endl;}arr1.PopBack();arr1.PopBack();cout<<" ==after arr1.getCapacity(): "<<arr1.getCapacity()<<endl;cout<<" ==after arr1.getSize(): "<<arr1.getSize()<<endl;for(int i=0; i<arr1.getSize(); i++){cout<<"after arr1[i]: " <<arr1[i]<<endl;}
}
class Person{
public:Person(){};Person(string name, int age){this->m_Name = name;this->m_Age = age;};string m_Name;int m_Age;
};void printPersonArray(MyArray<Person>& arr){for(int i=0; i<arr.getSize(); i++){cout<<" 姓名: "<<arr[i].m_Name<< " 年龄: "<<arr[i].m_Age<<endl;}
}
//测试自定义类型
void test07(){MyArray<Person> arr(10);Person p1("Damin",100);Person p2("Tony",70);Person p3("Tom",50);Person p4("Jarry",10);Person p5("Dalin",20);arr.PushBack(p1);arr.PushBack(p2);arr.PushBack(p3);arr.PushBack(p4);arr.PushBack(p5);printPersonArray(arr);cout<<" ==arr1.getCapacity(): "<<arr.getCapacity()<<endl;cout<<" ==arr1.getSize(): "<<arr.getSize()<<endl;
}int main()
{
//    test06();test07();return 0;
}

测试int类型:

测试自定义类型Person:

参考：

https://www.bilibili.com/video/BV1et411b73Z?p=175&spm_id_from=pageDriver

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/493077.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

芯片热！价格战！争落地！2018年人工智能发展回忆录

芯片热！价格战！争落地！2018年人工智能发展回忆录

来源&#xff1a;网易智能摘要&#xff1a;2018年是非同寻常的一年&#xff0c;对于人工智能行业而言更是如此。在这一年&#xff0c;几乎所有科技公司宣布全面拥抱AI&#xff0c;在这一年&#xff0c;巨头深入布局&#xff0c;挤压着创业者的想象空间&#xff0c;在这一年&…
阅读更多...
如何附加数据库

如何附加数据库

转载于:https://www.cnblogs.com/tanqianqian/p/5975072.html
阅读更多...
a16z基金：顶级风投眼中的2019技术趋势

a16z基金：顶级风投眼中的2019技术趋势

来源&#xff1a;资本实验室位于硅谷的顶级风险投资公司——安德森霍洛维兹基金&#xff08;Andreessen Horowitz&#xff0c;简称a16z&#xff09;在近期提出了他们将在2019年遵循的五大技术趋势&#xff0c;涉及生物医疗、数字货币与区块链、人工智能等技术领域。从字面上来看…
阅读更多...
新算力下的2019 AI

新算力下的2019 AI

来源&#xff1a;乐晴智库精选▌AI步入下半场IT每十年一阶段形成六大阶段每一轮科技革命都会带来新的赢家基础设施—通用平台—应用层的发展路径每一轮科技革命均印证基础设施先行的发展路径基础设施与通用平台易形成寡头垄断应用层的发展愈来愈依托于生态云计算厂商的资本开支…
阅读更多...
leetcode动态规划(python与c++)

leetcode动态规划(python与c++)

1 . 斐波那契数 class Solution:def fib(self, n: int) -> int:# if n0:# return 0# elif n1:# return 1# else:# return self.fib(n-1)self.fib(n-2)a 0b 1for i in range(n):a,b b,abreturn a class Solution { public:int fib(int n) {int a 0, b 1;fo…
阅读更多...
互联网50年类脑架构技术演化图

互联网50年类脑架构技术演化图

作者&#xff1a;刘锋 计算机博士 互联网进化论作者摘要&#xff1a;不断的有著名科学家或企业家提出互联网已死&#xff0c;将被新技术取代&#xff0c;最近绘制了一幅互联网50年的技术演化图&#xff0c;试图说明互联网从1969年四台计算机的网状结构发展成2019类脑结构的过程…
阅读更多...
小孔成像中四个坐标系转换

小孔成像中四个坐标系转换

一.小孔成像基础知识: 1.1透镜成像原理 如图所示&#xff1a; 其中 u 为物距&#xff0c; f 为焦距&#xff0c;v 为相距。三者满足关系式&#xff1a; 相机的镜头是一组透镜&#xff0c;当平行于主光轴的光线穿过透镜时&#xff0c;会聚到一点上&#xff0c;这个点叫做焦点&…
阅读更多...
这10项机器人领域的核心技术，你了解多少

这10项机器人领域的核心技术，你了解多少

来源&#xff1a;机器人创新生态NO 1&#xff0e;人机对话智能交互技术这项技术能让人类做到真正与机器智能的对话交流&#xff0c;机器人不仅能理解用户的问题并给出精准答案&#xff0c;还能在信息不全的情况下主动引导完成会话。当前这一块做得比较成熟的谷歌与Facebook。NO…
阅读更多...
leetcode哈希表(python与c++)

leetcode哈希表(python与c++)

1.整数转罗马数字 python: class Solution:def intToRoman(self, num: int) -> str:dict_ {1000:M, 900:CM, 500:D, 400:CD, 100:C, 90:XC, 50:L, 40:XL, 10:X, 9:IX, 5:V, 4:IV, 1:I}res for key in dict_:count num // keyres count * dict_[key]num % keyreturn res…
阅读更多...
Yann LeCun、吴恩达的新年AI预测：强调“少样本学习”，AI恐慌在减少

Yann LeCun、吴恩达的新年AI预测：强调“少样本学习”，AI恐慌在减少

来源&#xff1a;大数据文摘新年伊始&#xff0c;海外媒体VentureBeat电话访谈了包括吴恩达、Yann Lecun在内的四位人工智能领域领军者&#xff0c;询问了他们对于过去一年人工智能领域发展的看法&#xff0c;以及他们认为新一年人工智能和机器学习可能产生的突破。不约而同&am…
阅读更多...
1.C#WinForm基础制作简单计算器

1.C#WinForm基础制作简单计算器

利用c#语言编写简单计算器&#xff1a; 核心知识点&#xff1a; MessageBox.Show(Convert.ToString(comboBox1.SelectedIndex));//下拉序号MessageBox.Show(Convert.ToString(comboBox1.SelectedItem));//下拉内容MessageBox.Show(Convert.ToString(comboBox1.SelectedText));/…
阅读更多...
seaborn的一些画图

seaborn的一些画图

一.数据查看 数据集地址,用红白酒为例&#xff0e; import pandas as pd import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import matplotlib as mpl import numpy as np import seaborn as snswhite_wine pd.read_csv(winequality-white.csv, se…
阅读更多...
后摩尔定律时代的芯片新选择！

后摩尔定律时代的芯片新选择！

来源&#xff1a;gizmodo摘要&#xff1a;很长一段时间以来&#xff0c;摩尔定律和它的最终结局一直就像房间里的大象&#xff0c;不容忽视。英特尔联合创始人戈登摩尔在1965年的一篇论文中预测&#xff0c;芯片中的晶体管数量每年将翻一番。更多的晶体管意味着更快的速度&…
阅读更多...
MSE和Cross-entropy梯度更新比较

MSE和Cross-entropy梯度更新比较

一.平方损失(MSE) Loss函数: 梯度: 由于x,y是已知的&#xff0c;故可以忽略掉 梯度更新: sigmoid函数: 可以看出 导数在z取大部分值&#xff0c;都是很小的&#xff0c;这样会使梯度更新慢&#xff0e; y为1或0是&#xff0c;当a1,w的梯度为0,a0,w的梯度为0&#xff0c;故就…
阅读更多...
麦卡锡问答：什么是人工智能？

麦卡锡问答：什么是人工智能？

来源&#xff1a;科学网一、基本问题问&#xff1a;什么是人工智能&#xff1f;答&#xff1a;人工智能是研制智能机器尤其是智能计算机程序的科学与工程。它与使用计算机理解人类智能类似&#xff0c;但人工智能并不将它自己局限于生物意义上的方法。问&#xff1a;是的&#…
阅读更多...
操作系统--多进程管理CPU

操作系统--多进程管理CPU

一.cpu管理直观做法 最只管想法cpu循环取址执行&#xff0c;所以只需要设好pc初值即可 存在问题:io会占用时间长&#xff0c;导致cpu利用率低. 所以需要不停切换&#xff0c;执行多个程序&#xff0c;也就是并发&#xff0e; 但是在切换的时候&#xff0c;除了记录返回地址&a…
阅读更多...
胶囊网络、边缘计算：2018年13个最新人工智能发展趋势

胶囊网络、边缘计算：2018年13个最新人工智能发展趋势

来源&#xff1a;亿欧智库摘要&#xff1a; 美国知名研究机构CB Insights的报告《2018年必看的人工智能热门趋势》&#xff0c;对AI行业发展现状进行了深入研究剖析&#xff0c;并给出了2018年AI领域最值得关注的13个前沿发展趋势。趋势一&#xff1a;新蓝领的工作——机器人保…
阅读更多...
清空输入缓冲区fflush()

清空输入缓冲区fflush()

转自&#xff1a;http://blog.csdn.net/21aspnet/article/details/174326 scanf( )函数可以接收输入的换行符&#xff0c;\n,(asci为10)&#xff0c;利用函数fflush(stdin),可以清空输入内存缓冲区。 // function name fflush // 清空一个流 ,2014--03--29 #include <std…
阅读更多...
操作系统--用户级线程与内核级线程

操作系统--用户级线程与内核级线程

一.多进程是操作系统基本图像 进程都是在内核进行 二.用户级线程 2.1线程引入 可以切指令不切表&#xff0c;也就是资源不动&#xff0c;指令执行分开&#xff0c;更加轻量化&#xff0c;从而提高效率&#xff0c;保留并发优点&#xff0c;避免进程切换代价&#xff0c;也就…
阅读更多...
“新视野”和“最远点”的约会

“新视野”和“最远点”的约会

NASA 设想的2014 MU69 太空岩石 来源&#xff1a;中国科学报当新年香槟将陌生人聚在一起时&#xff0c;一种不同的聚会正在外太阳系进行。在距地球近65亿公里的地方&#xff0c;美国宇航局&#xff08;NASA&#xff09;“新视野”号探测器创下了寻访迄今最遥远世界的纪录。这场…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023