winsocket 申请套接字返回总是0,导致connect失败，求解啊

[llf22282776]

#include <stdio.h>
#include <winsock2.h>
#include <stdlib.h>


#pragma comment(lib,"ws2_32")
#define PROT 9001
#define MAX_SIZE 512
//using namespace std;
int main(){

SOCKET sock_fd;
struct sockaddr_in serve_addr;
WSADATA ws;
char ch;
char rcvBuf[MAX_SIZE];
char senBuf[MAX_SIZE];
int senlen;
int error1;
int makenum;
printf("*****************\n");
printf("正在连接linux````\n");
makenum=MAKEWORD(1,1);
error1=WSAStartup( makenum,&ws);
printf("%d\n",error1);
if ( LOBYTE( ws.wVersion ) != 1 ||
HIBYTE( ws.wVersion ) != 1 )
{
WSACleanup( );
printf("e\n");
getchar();
return;
}
if(sock_fd=socket(AF_INET,SOCK_STREAM,0)==INVALID_SOCKET)
{
printf("套接字申请失败\n");
exit(1);
}
printf("套接字为：%d\n",sock_fd);
memset(&serve_addr,0,sizeof(serve_addr));
serve_addr.sin_addr.S_un.S_addr=inet_addr("192.168.1.122");
serve_addr.sin_family=AF_INET;
serve_addr.sin_port=htons(PROT);
while(1){
if(connect(sock_fd,(struct sockaddr*)&serve_addr,sizeof(struct sockaddr))==SOCKET_ERROR){

int error=(int)WSAGetLastError();
printf("连接失败:%d，按y尝试继续连接:",error);
//cin.clear();
//cin.sync();
//cin>>ch;
fflush(stdin);
ch=getchar();
if(ch=='y')continue;
closesocket(sock_fd);
exit(1);
}
break;
}
while(1){
printf("请输入linux命令:");
memset(senBuf,'\0',512);
fflush(stdin);
scanf_s(senBuf);
strcat(senBuf,">/root/result");
if(strcmp(senBuf,"exit")==0)break;
if(send(sock_fd,senBuf,MAX_SIZE,0)==SOCKET_ERROR){
printf("发送失败\n");
continue;
}
memset(rcvBuf,'\0',512);
if(recv(sock_fd,rcvBuf,MAX_SIZE,0)==SOCKET_ERROR){
printf("接收失败\n");
continue;
}
printf(rcvBuf);

}
WSACleanup();
closesocket(sock_fd);
}

[赵4老师]

//C++ Operators
//  Operators specify an evaluation to be performed on one of the following:
//    One operand (unary operator)
//    Two operands (binary operator)
//    Three operands (ternary operator)
//  The C++ language includes all C operators and adds several new operators.
//  Table 1.1 lists the operators available in Microsoft C++.
//  Operators follow a strict precedence which defines the evaluation order of
//expressions containing these operators.  Operators associate with either the
//expression on their left or the expression on their right;    this is called
//“associativity.” Operators in the same group have equal precedence and are
//evaluated left to right in an expression unless explicitly forced by a pair of
//parentheses, ( ).
//  Table 1.1 shows the precedence and associativity of C++ operators
//  (from highest to lowest precedence).
//
//Table 1.1   C++ Operator Precedence and Associativity
// The highest precedence level is at the top of the table.
//+------------------+-----------------------------------------+---------------+
//| Operator         | Name or Meaning                         | Associativity |
//+------------------+-----------------------------------------+---------------+
//| ::               | Scope resolution                        | None          |
//| ::               | Global                                  | None          |
//| [ ]              | Array subscript                         | Left to right |
//| ( )              | Function call                           | Left to right |
//| ( )              | Conversion                              | None          |
//| .                | Member selection (object)               | Left to right |
//| ->               | Member selection (pointer)              | Left to right |
//| ++               | Postfix increment                       | None          |
//| --               | Postfix decrement                       | None          |
//| new              | Allocate object                         | None          |
//| delete           | Deallocate object                       | None          |
//| delete[ ]        | Deallocate object                       | None          |
//| ++               | Prefix increment                        | None          |
//| --               | Prefix decrement                        | None          |
//| *                | Dereference                             | None          |
//| &                | Address-of                              | None          |
//| +                | Unary plus                              | None          |
//| -                | Arithmetic negation (unary)             | None          |
//| !                | Logical NOT                             | None          |
//| ~                | Bitwise complement                      | None          |
//| sizeof           | Size of object                          | None          |
//| sizeof ( )       | Size of type                            | None          |
//| typeid( )        | type name                               | None          |
//| (type)           | Type cast (conversion)                  | Right to left |
//| const_cast       | Type cast (conversion)                  | None          |
//| dynamic_cast     | Type cast (conversion)                  | None          |
//| reinterpret_cast | Type cast (conversion)                  | None          |
//| static_cast      | Type cast (conversion)                  | None          |
//| .*               | Apply pointer to class member (objects) | Left to right |
//| ->*              | Dereference pointer to class member     | Left to right |
//| *                | Multiplication                          | Left to right |
//| /                | Division                                | Left to right |
//| %                | Remainder (modulus)                     | Left to right |
//| +                | Addition                                | Left to right |
//| -                | Subtraction                             | Left to right |
//| <<               | Left shift                              | Left to right |
//| >>               | Right shift                             | Left to right |
//| <                | Less than                               | Left to right |
//| >                | Greater than                            | Left to right |
//| <=               | Less than or equal to                   | Left to right |
//| >=               | Greater than or equal to                | Left to right |
//| ==               | Equality                                | Left to right |
//| !=               | Inequality                              | Left to right |
//| &                | Bitwise AND                             | Left to right |
//| ^                | Bitwise exclusive OR                    | Left to right |
//| |                | Bitwise OR                              | Left to right |
//| &&               | Logical AND                             | Left to right |
//| ||               | Logical OR                              | Left to right |
//| e1?e2:e3         | Conditional                             | Right to left |
//| =                | Assignment                              | Right to left |
//| *=               | Multiplication assignment               | Right to left |
//| /=               | Division assignment                     | Right to left |
//| %=               | Modulus assignment                      | Right to left |
//| +=               | Addition assignment                     | Right to left |
//| -=               | Subtraction assignment                  | Right to left |
//| <<=              | Left-shift assignment                   | Right to left |
//| >>=              | Right-shift assignment                  | Right to left |
//| &=               | Bitwise AND assignment                  | Right to left |
//| |=               | Bitwise inclusive OR assignment         | Right to left |
//| ^=               | Bitwise exclusive OR assignment         | Right to left |
//| ,                | Comma                                   | Left to right |
//+------------------+-----------------------------------------+---------------+

[赵4老师]

if((sock_fd=socket(AF_INET,SOCK_STREAM,0))==INVALID_SOCKET)

[llf22282776]

多谢了，这个问题实在是没注意到，细节决定成败啊